Bumped version to 2.9.9 (#228)

Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com>
(cherry picked from commit dc2e17c5db)

.editorconfig

@@ -7,10 +7,9 @@ root = true
 [*]
 end_of_line = lf
 insert_final_newline = true
-quote_type = single
 
 # Set default charset
 [*.{js,ts,scss,html}]
 charset = utf-8
 indent_style = space
-indent_size = 4
+indent_size = 2

.git-blame-ignore-revs

@@ -0,0 +1,2 @@
+# Apply Prettier https://github.com/bitwarden/directory-connector/pull/194
+096196fcd512944d1c3d9c007647a1319b032639

.github/PULL_REQUEST_TEMPLATE.md

@@ -0,0 +1,33 @@
+## Type of change
+
+- [ ] Bug fix
+- [ ] New feature development
+- [ ] Tech debt (refactoring, code cleanup, dependency upgrades, etc)
+- [ ] Build/deploy pipeline (DevOps)
+- [ ] Other
+
+## Objective
+
+<!--Describe what the purpose of this PR is. For example: what bug you're fixing or what new feature you're adding-->
+
+## Code changes
+
+<!--Explain the changes you've made to each file or major component. This should help the reviewer understand your changes-->
+<!--Also refer to any related changes or PRs in other repositories-->
+
+- **file.ext:** Description of what was changed and why
+
+## Screenshots
+
+<!--Required for any UI changes. Delete if not applicable-->
+
+## Testing requirements
+
+<!--What functionality requires testing by QA? This includes testing new behavior and regression testing-->
+
+## Before you submit
+
+- [ ] I have checked for **linting** errors (`npm run lint`) (required)
+- [ ] I have added **unit tests** where it makes sense to do so (encouraged but not required)
+- [ ] This change requires a **documentation update** (notify the documentation team)
+- [ ] This change has particular **deployment requirements** (notify the DevOps team)

.github/scripts/decrypt-secret.ps1

@@ -1,29 +0,0 @@
-param (
-  [Parameter(Mandatory=$true)]
-  [string] $filename,
-  [string] $output
-)
-
-$homePath = Resolve-Path "~" | Select-Object -ExpandProperty Path
-$rootPath = $env:GITHUB_WORKSPACE
-
-$secretInputPath = $rootPath + "/.github/secrets"
-$input = $secretInputPath + "/" + $filename
-
-$passphrase = $env:DECRYPT_FILE_PASSWORD
-$secretOutputPath = $homePath + "/secrets"
-
-if ([string]::IsNullOrEmpty($output)) {
-  if ($filename.EndsWith(".gpg")) {
-    $output = $secretOutputPath + "/" + $filename.TrimEnd(".gpg")
-  } else {
-    $output = $secretOutputPath + "/" + $filename + ".plaintext"
-  }
-}
-
-if (!(Test-Path -Path $secretOutputPath))  
-{
-  New-Item -ItemType Directory -Path $secretOutputPath 
-}
-
-gpg --quiet --batch --yes --decrypt --passphrase="$passphrase" --output $output $input

.github/scripts/load-version.ps1

@@ -1,5 +0,0 @@
-$rootPath = $env:GITHUB_WORKSPACE;
-$packageVersion = (Get-Content -Raw -Path $rootPath\src\package.json | ConvertFrom-Json).version;
-
-Write-Output "Setting package version to $packageVersion";
-Write-Output "PACKAGE_VERSION=$packageVersion" | Out-File -FilePath $env:GITHUB_ENV -Encoding utf8 -Append;

.github/scripts/macos/decrypt-secrets.ps1

@@ -1,7 +0,0 @@
-$rootPath = $env:GITHUB_WORKSPACE;
-
-$decryptSecretPath = $($rootPath + "/.github/scripts/decrypt-secret.ps1");
-
-Invoke-Expression "& `"$decryptSecretPath`" -filename devid-app-cert.p12.gpg"
-Invoke-Expression "& `"$decryptSecretPath`" -filename devid-installer-cert.p12.gpg"
-Invoke-Expression "& `"$decryptSecretPath`" -filename macdev-cert.p12.gpg"

.github/scripts/macos/setup-keychain.ps1

@@ -1,15 +0,0 @@
-$homePath = Resolve-Path "~" | Select-Object -ExpandProperty Path;
-$secretsPath = $homePath + "/secrets"
-
-$devidAppCertPath = $($secretsPath + "/devid-app-cert.p12");
-$devidInstallerCertPath = $($secretsPath + "/devid-installer-cert.p12");
-$macdevCertPath = $($secretsPath + "/macdev-cert.p12");
-
-security create-keychain -p $env:KEYCHAIN_PASSWORD build.keychain
-security default-keychain -s build.keychain
-security unlock-keychain -p $env:KEYCHAIN_PASSWORD build.keychain
-security set-keychain-settings -lut 1200 build.keychain
-security import $devidAppCertPath -k build.keychain -P $env:DEVID_CERT_PASSWORD -T /usr/bin/codesign -T /usr/bin/security -T /usr/bin/productbuild
-security import $devidInstallerCertPath -k build.keychain -P $env:DEVID_CERT_PASSWORD -T /usr/bin/codesign -T /usr/bin/security -T /usr/bin/productbuild
-security import $macdevCertPath -k build.keychain -P $env:MACDEV_CERT_PASSWORD -T /usr/bin/codesign -T /usr/bin/security -T /usr/bin/productbuild
-security set-key-partition-list -S apple-tool:,apple:,codesign: -s -k $env:KEYCHAIN_PASSWORD build.keychain

.github/workflows/build.yml

@@ -1,52 +1,234 @@
+---
 name: Build
 
 on:
   push:
     branches-ignore:
       - 'l10n_master'
-  workflow_dispatch:
-    inputs:
 
 
 jobs:
   cloc:
-    runs-on: ubuntu-latest
+    name: CLOC
+    runs-on: ubuntu-20.04
     steps:
       - name: Checkout repo
-        uses: actions/checkout@v2
+        uses: actions/checkout@5a4ac9002d0be2fb38bd78e4b4dbde5606d7042f  # v2.3.4
 
-      - name: Set up cloc
+      - name: Set up CLOC
         run: |
           sudo apt update
           sudo apt -y install cloc
+
       - name: Print lines of code
         run: cloc --include-lang TypeScript,JavaScript,HTML,Sass,CSS --vcs git
 
 
   setup:
-    runs-on: ubuntu-latest
+    name: Setup
+    runs-on: ubuntu-20.04
     outputs:
-      package_version: ${{ steps.get_version.outputs.package_version }}
+      package_version: ${{ steps.retrieve-version.outputs.package_version }}
     steps:
       - name: Checkout repo
-        uses: actions/checkout@v2
+        uses: actions/checkout@5a4ac9002d0be2fb38bd78e4b4dbde5606d7042f  # v2.3.4
 
       - name: Get Package Version
-        id: get_version
-        shell: pwsh
+        id: retrieve-version
         run: |
-          $env:pkgVersion = (Get-Content -Raw -Path ./src/package.json | ConvertFrom-Json).version
-          echo "::set-output name=PACKAGE_VERSION::$env:pkgVersion" 
+          PKG_VERSION=$(jq -r .version src/package.json)
+          echo "::set-output name=package_version::$PKG_VERSION"
 
 
-  cli:
-    runs-on: windows-latest
+  linux-cli:
+    name: Build Linux CLI
+    runs-on: ubuntu-20.04
     needs: setup
     env:
-      PACKAGE_VERSION: ${{ needs.setup.outputs.package_version }}
+      _PACKAGE_VERSION: ${{ needs.setup.outputs.package_version }}
+      _PKG_FETCH_NODE_VERSION: 16.13.0
+      _PKG_FETCH_VERSION: 3.2
     steps:
       - name: Checkout repo
-        uses: actions/checkout@v2
+        uses: actions/checkout@5a4ac9002d0be2fb38bd78e4b4dbde5606d7042f  # v2.3.4
+
+      - name: Set up Node
+        uses: actions/setup-node@46071b5c7a2e0c34e49c3cb8a0e792e86e18d5ea
+        with:
+          node-version: '16'
+
+      - name: Update NPM
+        run: |
+          npm install -g node-gyp
+          node-gyp install $(node -v)
+
+      - name: Get pkg-fetch
+        run: |
+          cd $HOME
+          fetchedUrl="https://github.com/vercel/pkg-fetch/releases/download/v$_PKG_FETCH_VERSION/node-v$_PKG_FETCH_NODE_VERSION-linux-x64"
+
+          mkdir -p .pkg-cache/v$_PKG_FETCH_VERSION
+          wget $fetchedUrl -O "./.pkg-cache/v$_PKG_FETCH_VERSION/fetched-v$_PKG_FETCH_NODE_VERSION-linux-x64"
+
+      - name: Keytar
+        run: |
+          keytarVersion=$(cat src/package.json | jq -r '.dependencies.keytar')
+          keytarTar="keytar-v$keytarVersion-napi-v3-linux-x64.tar"
+
+          keytarTarGz="$keytarTar.gz"
+          keytarUrl="https://github.com/atom/node-keytar/releases/download/v$keytarVersion/$keytarTarGz"
+
+          mkdir -p ./keytar/linux
+          wget $keytarUrl -O ./keytar/linux/$keytarTarGz
+          tar -xvf ./keytar/linux/$keytarTarGz -C ./keytar/linux
+
+      - name: Install
+        run: npm install
+
+      - name: Package CLI
+        run: npm run dist:cli:lin
+
+      - name: Zip
+        run: |
+          zip -j ./dist-cli/bwdc-linux-$_PACKAGE_VERSION.zip ./dist-cli/linux/bwdc ./keytar/linux/build/Release/keytar.node
+
+      - name: Create checksums
+        run: |
+          sha256sum ./dist-cli/bwdc-linux-$_PACKAGE_VERSION.zip | cut -d " " -f 1 > ./dist-cli/bwdc-linux-sha256-$_PACKAGE_VERSION.txt
+
+      - name: Version Test
+        run: |
+          sudo apt install libsecret-1-0 dbus-x11 gnome-keyring
+          eval $(dbus-launch --sh-syntax)
+          
+          eval $(echo -n "" | /usr/bin/gnome-keyring-daemon --login)
+          eval $(/usr/bin/gnome-keyring-daemon --components=secrets --start)
+
+          mkdir -p test/linux
+          unzip ./dist-cli/bwdc-linux-$_PACKAGE_VERSION.zip -d ./test/linux
+
+          testVersion=$(./test/linux/bwdc -v)
+
+          echo "version: $_PACKAGE_VERSION"
+          echo "testVersion: $testVersion"
+
+          if [ "$testVersion" != "$_PACKAGE_VERSION" ]; then
+            echo "Version test failed."
+            exit 1
+          fi
+
+      - name: Upload Linux Zip to GitHub
+        uses: actions/upload-artifact@ee69f02b3dfdecd58bb31b4d133da38ba6fe3700  # v2.2.3
+        with:
+          name: bwdc-linux-${{ env._PACKAGE_VERSION }}.zip
+          path: ./dist-cli/bwdc-linux-${{ env._PACKAGE_VERSION }}.zip
+          if-no-files-found: error
+
+      - name: Upload Linux checksum to GitHub
+        uses: actions/upload-artifact@ee69f02b3dfdecd58bb31b4d133da38ba6fe3700  # v2.2.3
+        with:
+          name: bwdc-linux-sha256-${{ env._PACKAGE_VERSION }}.txt
+          path: ./dist-cli/bwdc-linux-sha256-${{ env._PACKAGE_VERSION }}.txt
+          if-no-files-found: error
+
+
+  macos-cli:
+    name: Build Mac CLI
+    runs-on: macos-11
+    needs: setup
+    env:
+      _PACKAGE_VERSION: ${{ needs.setup.outputs.package_version }}
+      _PKG_FETCH_NODE_VERSION: 16.13.0
+      _PKG_FETCH_VERSION: 3.2
+    steps:
+      - name: Checkout repo
+        uses: actions/checkout@5a4ac9002d0be2fb38bd78e4b4dbde5606d7042f  # v2.3.4
+
+      - name: Set up Node
+        uses: actions/setup-node@46071b5c7a2e0c34e49c3cb8a0e792e86e18d5ea
+        with:
+          node-version: '16'
+
+      - name: Update NPM
+        run: |
+          npm install -g node-gyp
+          node-gyp install $(node -v)
+
+      - name: Get pkg-fetch
+        run: |
+          cd $HOME
+          fetchedUrl="https://github.com/vercel/pkg-fetch/releases/download/v$_PKG_FETCH_VERSION/node-v$_PKG_FETCH_NODE_VERSION-macos-x64"
+
+          mkdir -p .pkg-cache/v$_PKG_FETCH_VERSION
+          wget $fetchedUrl -O "./.pkg-cache/v$_PKG_FETCH_VERSION/fetched-v$_PKG_FETCH_NODE_VERSION-macos-x64"
+
+      - name: Keytar
+        run: |
+          keytarVersion=$(cat src/package.json | jq -r '.dependencies.keytar')
+          keytarTar="keytar-v$keytarVersion-napi-v3-darwin-x64.tar"
+
+          keytarTarGz="$keytarTar.gz"
+          keytarUrl="https://github.com/atom/node-keytar/releases/download/v$keytarVersion/$keytarTarGz"
+
+          mkdir -p ./keytar/macos
+          wget $keytarUrl -O ./keytar/macos/$keytarTarGz
+          tar -xvf ./keytar/macos/$keytarTarGz -C ./keytar/macos
+
+      - name: Install
+        run: npm install
+
+      - name: Package CLI
+        run: npm run dist:cli:mac
+
+      - name: Zip
+        run: |
+          zip -j ./dist-cli/bwdc-macos-$_PACKAGE_VERSION.zip ./dist-cli/macos/bwdc ./keytar/macos/build/Release/keytar.node
+
+      - name: Create checksums
+        run: |
+          sha256sum ./dist-cli/bwdc-macos-$_PACKAGE_VERSION.zip | cut -d " " -f 1 > ./dist-cli/bwdc-macos-sha256-$_PACKAGE_VERSION.txt
+
+      - name: Version Test
+        run: |
+          mkdir -p test/macos
+          unzip ./dist-cli/bwdc-macos-$_PACKAGE_VERSION.zip -d ./test/macos
+
+          testVersion=$(./test/macos/bwdc -v)
+
+          echo "version: $_PACKAGE_VERSION"
+          echo "testVersion: $testVersion"
+
+          if [ "$testVersion" != "$_PACKAGE_VERSION" ]; then
+            echo "Version test failed."
+            exit 1
+          fi
+
+      - name: Upload Mac Zip to GitHub
+        uses: actions/upload-artifact@ee69f02b3dfdecd58bb31b4d133da38ba6fe3700  # v2.2.3
+        with:
+          name: bwdc-macos-${{ env._PACKAGE_VERSION }}.zip
+          path: ./dist-cli/bwdc-macos-${{ env._PACKAGE_VERSION }}.zip
+          if-no-files-found: error
+
+      - name: Upload Mac checksum to GitHub
+        uses: actions/upload-artifact@ee69f02b3dfdecd58bb31b4d133da38ba6fe3700  # v2.2.3
+        with:
+          name: bwdc-macos-sha256-${{ env._PACKAGE_VERSION }}.txt
+          path: ./dist-cli/bwdc-macos-sha256-${{ env._PACKAGE_VERSION }}.txt
+          if-no-files-found: error
+
+
+  windows-cli:
+    name: Build Windows CLI
+    runs-on: windows-2019
+    needs: setup
+    env:
+      _PACKAGE_VERSION: ${{ needs.setup.outputs.package_version }}
+      _WIN_PKG_FETCH_VERSION: 16.13.0
+      _WIN_PKG_VERSION: 3.2
+    steps:
+      - name: Checkout repo
+        uses: actions/checkout@5a4ac9002d0be2fb38bd78e4b4dbde5606d7042f  # v2.3.4
 
       - name: Setup Windows builder
         run: |
@@ -54,62 +236,86 @@ jobs:
           choco install reshack --no-progress
 
       - name: Set up Node
-        uses: actions/setup-node@v1
+        uses: actions/setup-node@46071b5c7a2e0c34e49c3cb8a0e792e86e18d5ea
         with:
-          node-version: '10.x'
+          node-version: '16'
 
-      - name: Setting WIN_PKG
+      - name: Update NPM
         run: |
-          echo "WIN_PKG=$env:WIN_PKG" | Out-File -FilePath $env:GITHUB_ENV -Encoding utf8 -Append
-          echo "version: $env:pkgVersion"
-        env:
-          WIN_PKG: C:\Users\runneradmin\.pkg-cache\v2.5\fetched-v10.4.1-win-x64
+          npm install -g node-gyp
+          node-gyp install $(node -v)
 
-      - name: get pkg-fetch
+      - name: Get pkg-fetch
         shell: pwsh
         run: |
           cd $HOME
-          $fetchedUrl = "https://github.com/vercel/pkg-fetch/releases/download/v2.5/uploaded-v2.5-node-v10.4.1-win-x64"
+          $fetchedUrl = "https://github.com/vercel/pkg-fetch/releases/download/v$env:_WIN_PKG_VERSION/node-v$env:_WIN_PKG_FETCH_VERSION-win-x64"
 
           New-Item -ItemType directory -Path ./.pkg-cache
-          New-Item -ItemType directory -Path ./.pkg-cache/v2.5
-          Invoke-RestMethod -Uri $fetchedUrl -OutFile "./.pkg-cache/v2.5/fetched-v10.4.1-win-x64"
-        env:
-          WIN_PKG: C:\Users\runneradmin\.pkg-cache\v2.5\fetched-v10.4.1-win-x64
+          New-Item -ItemType directory -Path ./.pkg-cache/v$env:_WIN_PKG_VERSION
+          Invoke-RestMethod -Uri $fetchedUrl `
+            -OutFile "./.pkg-cache/v$env:_WIN_PKG_VERSION/fetched-v$env:_WIN_PKG_FETCH_VERSION-win-x64"
 
       - name: Keytar
         shell: pwsh
         run: |
           $keytarVersion = (Get-Content -Raw -Path ./src/package.json | ConvertFrom-Json).dependencies.keytar
-          $nodeModVersion = node -e "console.log(process.config.variables.node_module_version)"
-          $keytarTar = "keytar-v${keytarVersion}-node-v${nodeModVersion}-{0}-x64.tar"
+          $keytarTar = "keytar-v${keytarVersion}-napi-v3-{0}-x64.tar"
           $keytarTarGz = "${keytarTar}.gz"
           $keytarUrl = "https://github.com/atom/node-keytar/releases/download/v${keytarVersion}/${keytarTarGz}"
 
-          New-Item -ItemType directory -Path ./keytar/macos | Out-Null
-          New-Item -ItemType directory -Path ./keytar/linux | Out-Null
           New-Item -ItemType directory -Path ./keytar/windows | Out-Null
 
-          Invoke-RestMethod -Uri $($keytarUrl -f "darwin") -OutFile "./keytar/macos/$($keytarTarGz -f "darwin")"
-          Invoke-RestMethod -Uri $($keytarUrl -f "linux") -OutFile "./keytar/linux/$($keytarTarGz -f "linux")"
           Invoke-RestMethod -Uri $($keytarUrl -f "win32") -OutFile "./keytar/windows/$($keytarTarGz -f "win32")"
 
-          7z e "./keytar/macos/$($keytarTarGz -f "darwin")" -o"./keytar/macos"
-          7z e "./keytar/linux/$($keytarTarGz -f "linux")" -o"./keytar/linux"
           7z e "./keytar/windows/$($keytarTarGz -f "win32")" -o"./keytar/windows"
 
-          7z e "./keytar/macos/$($keytarTar -f "darwin")" -o"./keytar/macos"
-          7z e "./keytar/linux/$($keytarTar -f "linux")" -o"./keytar/linux"
           7z e "./keytar/windows/$($keytarTar -f "win32")" -o"./keytar/windows"
 
       - name: Setup Version Info
         shell: pwsh
-        run: ./scripts/make-versioninfo.ps1
+        run: |
+          $major, $minor, $patch = $env:_PACKAGE_VERSION.split('.')
+
+          $versionInfo = @"
+
+          1 VERSIONINFO
+          FILEVERSION $major,$minor,$patch,0
+          PRODUCTVERSION $major,$minor,$patch,0
+          FILEOS 0x40004
+          FILETYPE 0x1
+          {
+          BLOCK "StringFileInfo"
+          {
+            BLOCK "040904b0"
+            {
+              VALUE "CompanyName", "Bitwarden Inc."
+              VALUE "ProductName", "Bitwarden"
+              VALUE "FileDescription", "Bitwarden Directory Connector CLI"
+              VALUE "FileVersion", "$env:_PACKAGE_VERSION"
+              VALUE "ProductVersion", "$env:_PACKAGE_VERSION"
+              VALUE "OriginalFilename", "bwdc.exe"
+              VALUE "InternalName", "bwdc"
+              VALUE "LegalCopyright", "Copyright Bitwarden Inc."
+            }
+          }
+
+          BLOCK "VarFileInfo"
+          {
+            VALUE "Translation", 0x0409 0x04B0
+          }
+          }
+          "@
+
+          $versionInfo | Out-File ./version-info.rc
 
       - name: Resource Hacker
         shell: cmd
         run: |
           set PATH=%PATH%;C:\Program Files (x86)\Resource Hacker
+          set WIN_PKG=C:\Users\runneradmin\.pkg-cache\v%_WIN_PKG_VERSION%\fetched-v%_WIN_PKG_FETCH_VERSION%-win-x64
+          set WIN_PKG_BUILT=C:\Users\runneradmin\.pkg-cache\v%_WIN_PKG_VERSION%\built-v%_WIN_PKG_FETCH_VERSION%-win-x64
+
           ResourceHacker -open %WIN_PKG% -save %WIN_PKG% -action delete -mask ICONGROUP,1,
           ResourceHacker -open version-info.rc -save version-info.res -action compile
           ResourceHacker -open %WIN_PKG% -save %WIN_PKG% -action addoverwrite -resource version-info.res
@@ -118,92 +324,64 @@ jobs:
         run: npm install
 
       - name: Package CLI
-        run: npm run dist:cli
+        run: npm run dist:cli:win
 
       - name: Zip
         shell: cmd
         run: |
-          7z a ./dist-cli/bwdc-windows-%PACKAGE_VERSION%.zip ./dist-cli/windows/bwdc.exe ./keytar/windows/keytar.node
-          7z a ./dist-cli/bwdc-macos-%PACKAGE_VERSION%.zip ./dist-cli/macos/bwdc ./keytar/macos/keytar.node
-          7z a ./dist-cli/bwdc-linux-%PACKAGE_VERSION%.zip ./dist-cli/linux/bwdc ./keytar/linux/keytar.node
+          7z a ./dist-cli/bwdc-windows-%_PACKAGE_VERSION%.zip ./dist-cli/windows/bwdc.exe ./keytar/windows/keytar.node
 
       - name: Version Test
         run: |
-          Expand-Archive -Path "./dist-cli/bwdc-windows-${env:PACKAGE_VERSION}.zip" -DestinationPath "./test/windows"
+          Expand-Archive -Path "./dist-cli/bwdc-windows-${env:_PACKAGE_VERSION}.zip" -DestinationPath "./test/windows"
           $testVersion = Invoke-Expression '& ./test/windows/bwdc.exe -v'
-          echo "version: $env:PACKAGE_VERSION"
+          echo "version: $env:_PACKAGE_VERSION"
           echo "testVersion: $testVersion"
-          if($testVersion -ne $env:PACKAGE_VERSION) {
+          if($testVersion -ne $env:_PACKAGE_VERSION) {
             Throw "Version test failed."
           }
 
       - name: Create checksums
         run: |
-          checksum -f="./dist-cli/bwdc-windows-${env:PACKAGE_VERSION}.zip" `
-            -t sha256 | Out-File ./dist-cli/bwdc-windows-sha256-${env:PACKAGE_VERSION}.txt
-          checksum -f="./dist-cli/bwdc-macos-${env:PACKAGE_VERSION}.zip" `
-            -t sha256 | Out-File ./dist-cli/bwdc-macos-sha256-${env:PACKAGE_VERSION}.txt
-          checksum -f="./dist-cli/bwdc-linux-${env:PACKAGE_VERSION}.zip" `
-            -t sha256 | Out-File ./dist-cli/bwdc-linux-sha256-${env:PACKAGE_VERSION}.txt
+          checksum -f="./dist-cli/bwdc-windows-${env:_PACKAGE_VERSION}.zip" `
+            -t sha256 | Out-File ./dist-cli/bwdc-windows-sha256-${env:_PACKAGE_VERSION}.txt
 
-      - name: Upload windows zip to GitHub
-        if: github.ref == 'refs/heads/master' || github.ref == 'refs/heads/rc'
-        uses: actions/upload-artifact@v2
+      - name: Upload Windows Zip to GitHub
+        uses: actions/upload-artifact@ee69f02b3dfdecd58bb31b4d133da38ba6fe3700  # v2.2.3
         with:
-          name: bwdc-windows-${{ env.PACKAGE_VERSION }}.zip
-          path: ./dist-cli/bwdc-windows-${{ env.PACKAGE_VERSION }}.zip
+          name: bwdc-windows-${{ env._PACKAGE_VERSION }}.zip
+          path: ./dist-cli/bwdc-windows-${{ env._PACKAGE_VERSION }}.zip
+          if-no-files-found: error
 
-      - name: Upload mac zip to GitHub
-        if: github.ref == 'refs/heads/master' || github.ref == 'refs/heads/rc'
-        uses: actions/upload-artifact@v2
+      - name: Upload Windows checksum to GitHub
+        uses: actions/upload-artifact@ee69f02b3dfdecd58bb31b4d133da38ba6fe3700  # v2.2.3
         with:
-          name: bwdc-macos-${{ env.PACKAGE_VERSION }}.zip
-          path: ./dist-cli/bwdc-macos-${{ env.PACKAGE_VERSION }}.zip
-
-      - name: Upload linux zip to GitHub
-        if: github.ref == 'refs/heads/master' || github.ref == 'refs/heads/rc'
-        uses: actions/upload-artifact@v2
-        with:
-          name: bwdc-linux-${{ env.PACKAGE_VERSION }}.zip
-          path: ./dist-cli/bwdc-linux-${{ env.PACKAGE_VERSION }}.zip
-
-      - name: Upload windows checksum to GitHub
-        if: github.ref == 'refs/heads/master' || github.ref == 'refs/heads/rc'
-        uses: actions/upload-artifact@v2
-        with:
-          name: bwdc-windows-sha256-${{ env.PACKAGE_VERSION }}.txt
-          path: ./dist-cli/bwdc-windows-sha256-${{ env.PACKAGE_VERSION }}.txt
-
-      - name: Upload mac checksum to GitHub
-        if: github.ref == 'refs/heads/master' || github.ref == 'refs/heads/rc'
-        uses: actions/upload-artifact@v2
-        with:
-          name: bwdc-macos-sha256-${{ env.PACKAGE_VERSION }}.txt
-          path: ./dist-cli/bwdc-macos-sha256-${{ env.PACKAGE_VERSION }}.txt
-
-      - name: Upload linux checksum to GitHub
-        if: github.ref == 'refs/heads/master' || github.ref == 'refs/heads/rc'
-        uses: actions/upload-artifact@v2
-        with:
-          name: bwdc-linux-sha256-${{ env.PACKAGE_VERSION }}.txt
-          path: ./dist-cli/bwdc-linux-sha256-${{ env.PACKAGE_VERSION }}.txt
+          name: bwdc-windows-sha256-${{ env._PACKAGE_VERSION }}.txt
+          path: ./dist-cli/bwdc-windows-sha256-${{ env._PACKAGE_VERSION }}.txt
+          if-no-files-found: error
 
 
-  windows_gui:
-    runs-on: windows-latest
+  windows-gui:
+    name: Build Windows GUI
+    runs-on: windows-2019
     needs: setup
     env:
-      PACKAGE_VERSION: ${{ needs.setup.outputs.package_version }}
+      _PACKAGE_VERSION: ${{ needs.setup.outputs.package_version }}
     steps:
-      - name: Set up dotnet
-        uses: actions/setup-dotnet@v1
+      - name: Set up .NET
+        uses: actions/setup-dotnet@a71d1eb2c86af85faa8c772c03fb365e377e45ea
         with:
           dotnet-version: "3.1.x"
 
       - name: Set up Node
-        uses: actions/setup-node@v1
+        uses: actions/setup-node@46071b5c7a2e0c34e49c3cb8a0e792e86e18d5ea
         with:
-          node-version: '10.x'
+          node-version: '16'
+
+      - name: Update NPM
+        run: |
+          npm install -g node-gyp
+          node-gyp install $(node -v)
 
       - name: Set Node options
         run: echo "NODE_OPTIONS=--max_old_space_size=4096" | Out-File -FilePath $env:GITHUB_ENV -Encoding utf8 -Append
@@ -216,33 +394,16 @@ jobs:
           dotnet --version
 
       - name: Install AST
-        shell: pwsh
-        run: |
-          cd $HOME
-
-          git clone https://github.com/vcsjones/AzureSignTool.git
-          cd AzureSignTool
-          $latest_head = $(git rev-parse HEAD)[0..9] -join ""
-          $latest_version = "0.0.0-g$latest_head"
-
-          Write-Host "--------"
-          Write-Host "git commit - $(git rev-parse HEAD)"
-          Write-Host "latest_head - $latest_head"
-          Write-Host "PACKAGE VERSION TO BUILD - $latest_version"
-          Write-Host "--------"
-
-          dotnet restore
-          dotnet pack --output ./nupkg
-          dotnet tool install --global --ignore-failed-sources --add-source ./nupkg --version $latest_version azuresigntool
+        uses: bitwarden/gh-actions/install-ast@f135c42c8596cb535c5bcb7523c0b2eef89709ac
 
       - name: Checkout repo
-        uses: actions/checkout@v2
+        uses: actions/checkout@5a4ac9002d0be2fb38bd78e4b4dbde5606d7042f  # v2.3.4
 
       - name: Install Node dependencies
         run: npm install
 
-      - name: Run linter
-        run: npm run lint
+      # - name: Run linter
+      #   run: npm run lint
 
       - name: Build & Sign
         run: npm run dist:win
@@ -254,34 +415,51 @@ jobs:
           SIGNING_CLIENT_SECRET: ${{ secrets.SIGNING_CLIENT_SECRET }}
           SIGNING_CERT_NAME: ${{ secrets.SIGNING_CERT_NAME }}
 
-      - name: List Dist
-        run: dir ./dist
-
-      - name: Publish Portable Exe to GitHub
-        if: github.ref == 'refs/heads/master' || github.ref == 'refs/heads/rc'
-        uses: actions/upload-artifact@v2
+      - name: Upload Portable Executable to GitHub
+        uses: actions/upload-artifact@ee69f02b3dfdecd58bb31b4d133da38ba6fe3700  # v2.2.3
         with:
-          name: Bitwarden-Connector-Portable-${{ env.PACKAGE_VERSION }}.exe
-          path: ./dist/Bitwarden-Connector-Portable-${{ env.PACKAGE_VERSION }}.exe
+          name: Bitwarden-Connector-Portable-${{ env._PACKAGE_VERSION }}.exe
+          path: ./dist/Bitwarden-Connector-Portable-${{ env._PACKAGE_VERSION }}.exe
+          if-no-files-found: error
 
-      - name: Publish Installer Exe to GitHub
-        if: github.ref == 'refs/heads/master' || github.ref == 'refs/heads/rc'
-        uses: actions/upload-artifact@v2
+      - name: Upload Installer Executable to GitHub
+        uses: actions/upload-artifact@ee69f02b3dfdecd58bb31b4d133da38ba6fe3700  # v2.2.3
         with:
-          name: Bitwarden-Connector-Installer-${{ env.PACKAGE_VERSION }}.exe
-          path: ./dist/Bitwarden-Connector-Installer-${{ env.PACKAGE_VERSION }}.exe
+          name: Bitwarden-Connector-Installer-${{ env._PACKAGE_VERSION }}.exe
+          path: ./dist/Bitwarden-Connector-Installer-${{ env._PACKAGE_VERSION }}.exe
+          if-no-files-found: error
+
+      - name: Upload Installer Executable Blockmap to GitHub
+        uses: actions/upload-artifact@ee69f02b3dfdecd58bb31b4d133da38ba6fe3700  # v2.2.3
+        with:
+          name: Bitwarden-Connector-Installer-${{ env._PACKAGE_VERSION }}.exe.blockmap
+          path: ./dist/Bitwarden-Connector-Installer-${{ env._PACKAGE_VERSION }}.exe.blockmap
+          if-no-files-found: error
+
+      - name: Upload latest auto-update artifact
+        uses: actions/upload-artifact@ee69f02b3dfdecd58bb31b4d133da38ba6fe3700  # v2.2.3
+        with:
+          name: latest.yml
+          path: ./dist/latest.yml
+          if-no-files-found: error
 
 
-  linux:
-    runs-on: ubuntu-latest
+  linux-gui:
+    name: Build Linux GUI
+    runs-on: ubuntu-20.04
     needs: setup
     env:
-      PACKAGE_VERSION: ${{ needs.setup.outputs.package_version }}
+      _PACKAGE_VERSION: ${{ needs.setup.outputs.package_version }}
     steps:
       - name: Set up Node
-        uses: actions/setup-node@v1
+        uses: actions/setup-node@46071b5c7a2e0c34e49c3cb8a0e792e86e18d5ea
         with:
-          node-version: '10.x'
+          node-version: '16'
+
+      - name: Update NPM
+        run: |
+          npm install -g node-gyp
+          node-gyp install $(node -v)
 
       - name: Set Node options
         run: echo "NODE_OPTIONS=--max_old_space_size=4096" >> $GITHUB_ENV
@@ -293,35 +471,48 @@ jobs:
           sudo apt-get -y install rpm
 
       - name: Checkout repo
-        uses: actions/checkout@v2
+        uses: actions/checkout@5a4ac9002d0be2fb38bd78e4b4dbde5606d7042f  # v2.3.4
 
-      - name: npm install
+      - name: NPM Install
         run: npm install
 
-      - name: npm rebuild
+      - name: NPM Rebuild
         run: npm run rebuild
 
-      - name: npm package
+      - name: NPM Package
         run: npm run dist:lin
 
-      - name: Publish AppImage
-        if: github.ref == 'refs/heads/master' || github.ref == 'refs/heads/rc'
-        uses: actions/upload-artifact@v2
+      - name: Upload AppImage
+        uses: actions/upload-artifact@ee69f02b3dfdecd58bb31b4d133da38ba6fe3700  # v2.2.3
         with:
-          name: Bitwarden-Connector-${{ env.PACKAGE_VERSION }}-x86_64.AppImage
-          path: ./dist/Bitwarden-Connector-${{ env.PACKAGE_VERSION }}-x86_64.AppImage
+          name: Bitwarden-Connector-${{ env._PACKAGE_VERSION }}-x86_64.AppImage
+          path: ./dist/Bitwarden-Connector-${{ env._PACKAGE_VERSION }}-x86_64.AppImage
+          if-no-files-found: error
+
+      - name: Upload latest auto-update artifact
+        uses: actions/upload-artifact@ee69f02b3dfdecd58bb31b4d133da38ba6fe3700  # v2.2.3
+        with:
+          name: latest-linux.yml
+          path: ./dist/latest-linux.yml
+          if-no-files-found: error
 
 
-  macos:
-    runs-on: macos-latest
+  macos-gui:
+    name: Build MacOS GUI
+    runs-on: macos-11
     needs: setup
     env:
-      PACKAGE_VERSION: ${{ needs.setup.outputs.package_version }}
+      _PACKAGE_VERSION: ${{ needs.setup.outputs.package_version }}
     steps:
       - name: Set up Node
-        uses: actions/setup-node@v1
+        uses: actions/setup-node@46071b5c7a2e0c34e49c3cb8a0e792e86e18d5ea
         with:
-          node-version: '10.x'
+          node-version: '16'
+
+      - name: Update NPM
+        run: |
+          npm install -g node-gyp
+          node-gyp install $(node -v)
 
       - name: Set Node options
         run: echo "NODE_OPTIONS=--max_old_space_size=4096" >> $GITHUB_ENV
@@ -330,61 +521,168 @@ jobs:
         run: |
           node --version
           npm --version
-          Write-Output "GitHub ref: $env:GITHUB_REF"
-          Write-Output "GitHub event: $env:GITHUB_EVENT"
-        shell: pwsh
-        env:
-          GITHUB_REF: ${{ github.ref }}
-          GITHUB_EVENT: ${{ github.event_name }}
+          echo "GitHub ref: $GITHUB_REF"
+          echo "GitHub event: $GITHUB_EVENT"
+        shell: bash
 
       - name: Checkout repo
-        uses: actions/checkout@v2
+        uses: actions/checkout@5a4ac9002d0be2fb38bd78e4b4dbde5606d7042f  # v2.3.4
 
       - name: Decrypt secrets
-        run: ./.github/scripts/macos/decrypt-secrets.ps1
-        shell: pwsh
         env:
           DECRYPT_FILE_PASSWORD: ${{ secrets.DECRYPT_FILE_PASSWORD }}
+        shell: bash
+        run: |
+          mkdir -p $HOME/secrets
+
+          gpg --quiet --batch --yes --decrypt --passphrase="$DECRYPT_FILE_PASSWORD" \
+            --output "$HOME/secrets/devid-app-cert.p12" \
+            "$GITHUB_WORKSPACE/.github/secrets/devid-app-cert.p12.gpg"
+
+          gpg --quiet --batch --yes --decrypt --passphrase="$DECRYPT_FILE_PASSWORD" \
+            --output "$HOME/secrets/devid-installer-cert.p12" \
+            "$GITHUB_WORKSPACE/.github/secrets/devid-installer-cert.p12.gpg"
+
+          gpg --quiet --batch --yes --decrypt --passphrase="$DECRYPT_FILE_PASSWORD" \
+            --output "$HOME/secrets/macdev-cert.p12" \
+            "$GITHUB_WORKSPACE/.github/secrets/macdev-cert.p12.gpg"
 
       - name: Set up keychain
-        run: ./.github/scripts/macos/setup-keychain.ps1
-        shell: pwsh
         env:
           KEYCHAIN_PASSWORD: ${{ secrets.KEYCHAIN_PASSWORD }}
           DEVID_CERT_PASSWORD: ${{ secrets.DEVID_CERT_PASSWORD }}
           MACDEV_CERT_PASSWORD: ${{ secrets.MACDEV_CERT_PASSWORD }}
+        shell: bash
+        run: |
+          security create-keychain -p $KEYCHAIN_PASSWORD build.keychain
+          security default-keychain -s build.keychain
+          security unlock-keychain -p $KEYCHAIN_PASSWORD build.keychain
+          security set-keychain-settings -lut 1200 build.keychain
+          security import "$HOME/secrets/devid-app-cert.p12" -k build.keychain -P $DEVID_CERT_PASSWORD \
+            -T /usr/bin/codesign -T /usr/bin/security -T /usr/bin/productbuild
+          security import "$HOME/secrets/devid-installer-cert.p12" -k build.keychain -P $DEVID_CERT_PASSWORD \
+            -T /usr/bin/codesign -T /usr/bin/security -T /usr/bin/productbuild
+          security import "$HOME/secrets/macdev-cert.p12" -k build.keychain -P $MACDEV_CERT_PASSWORD \
+            -T /usr/bin/codesign -T /usr/bin/security -T /usr/bin/productbuild
+          security set-key-partition-list -S apple-tool:,apple:,codesign: -s -k $KEYCHAIN_PASSWORD build.keychain
 
       - name: Load package version
-        run: ./.github/scripts/load-version.ps1
+        run: |
+          $rootPath = $env:GITHUB_WORKSPACE;
+          $packageVersion = (Get-Content -Raw -Path $rootPath\src\package.json | ConvertFrom-Json).version;
+
+          Write-Output "Setting package version to $packageVersion";
+          Write-Output "PACKAGE_VERSION=$packageVersion" | Out-File -FilePath $env:GITHUB_ENV -Encoding utf8 -Append;
         shell: pwsh
 
       - name: Install Node dependencies
         run: npm install
 
-      - name: Run linter
-        run: npm run lint
+      # - name: Run linter
+      #   run: npm run lint
 
-      - name: Build application (dev)
-        if: github.ref != 'refs/heads/master'
-        run: npm run build
-
-      - name: Build application (dist)
-        if: github.ref == 'refs/heads/master' || github.ref == 'refs/heads/rc'
+      - name: Build application
         run: npm run dist:mac
         env:
           APPLE_ID_USERNAME: ${{ secrets.APPLE_ID_USERNAME }}
           APPLE_ID_PASSWORD: ${{ secrets.APPLE_ID_PASSWORD }}
 
+      - name: Rename Zip Artifact
+        run: |
+          cd dist
+          mv "Bitwarden Directory Connector-${{ env._PACKAGE_VERSION }}-mac.zip" \
+             "Bitwarden-Connector-${{ env._PACKAGE_VERSION }}-mac.zip"
+
       - name: Upload .zip artifact
-        if: github.ref == 'refs/heads/master' || github.ref == 'refs/heads/rc'
-        uses: actions/upload-artifact@v2
+        uses: actions/upload-artifact@ee69f02b3dfdecd58bb31b4d133da38ba6fe3700  # v2.2.3
         with:
-          name: Bitwarden-Connector-${{ env.PACKAGE_VERSION }}-mac.zip
-          path: ./dist/Bitwarden-Connector-${{ env.PACKAGE_VERSION }}-mac.zip
+          name: Bitwarden-Connector-${{ env._PACKAGE_VERSION }}-mac.zip
+          path: ./dist/Bitwarden-Connector-${{ env._PACKAGE_VERSION }}-mac.zip
+          if-no-files-found: error
 
       - name: Upload .dmg artifact
-        if: github.ref == 'refs/heads/master' || github.ref == 'refs/heads/rc'
-        uses: actions/upload-artifact@v2
+        uses: actions/upload-artifact@ee69f02b3dfdecd58bb31b4d133da38ba6fe3700  # v2.2.3
         with:
-          name: Bitwarden-Connector-${{ env.PACKAGE_VERSION }}.dmg
-          path: ./dist/Bitwarden-Connector-${{ env.PACKAGE_VERSION }}.dmg
+          name: Bitwarden-Connector-${{ env._PACKAGE_VERSION }}.dmg
+          path: ./dist/Bitwarden-Connector-${{ env._PACKAGE_VERSION }}.dmg
+          if-no-files-found: error
+
+      - name: Upload .dmg Blockmap artifact
+        uses: actions/upload-artifact@ee69f02b3dfdecd58bb31b4d133da38ba6fe3700  # v2.2.3
+        with:
+          name: Bitwarden-Connector-${{ env._PACKAGE_VERSION }}.dmg.blockmap
+          path: ./dist/Bitwarden-Connector-${{ env._PACKAGE_VERSION }}.dmg.blockmap
+          if-no-files-found: error
+
+      - name: Upload latest auto-update artifact
+        uses: actions/upload-artifact@ee69f02b3dfdecd58bb31b4d133da38ba6fe3700  # v2.2.3
+        with:
+          name: latest-mac.yml
+          path: ./dist/latest-mac.yml
+          if-no-files-found: error
+
+
+  check-failures:
+    name: Check for failures
+    runs-on: ubuntu-20.04
+    needs:
+      - cloc
+      - setup
+      - linux-cli
+      - macos-cli
+      - windows-cli
+      - windows-gui
+      - linux-gui
+      - macos-gui
+    steps:
+      - name: Check if any job failed
+        if: ${{ (github.ref == 'refs/heads/master') || (github.ref == 'refs/heads/rc') }}
+        env:
+          CLOC_STATUS: ${{ needs.cloc.result }}
+          SETUP_STATUS: ${{ needs.setup.result }}
+          LINUX_CLI_STATUS: ${{ needs.linux-cli.result }}
+          MACOS_CLI_STATUS: ${{ needs.macos-cli.result }}
+          WINDOWS_CLI_STATUS: ${{ needs.windows-cli.result }}
+          WINDOWS_GUI_STATUS: ${{ needs.windows-gui.result }}
+          LINUX_GUI_STATUS: ${{ needs.linux-gui.result }}
+          MACOS_GUI_STATUS: ${{ needs.macos-gui.result }}
+        run: |
+          if [ "$CLOC_STATUS" = "failure" ]; then
+              exit 1
+          elif [ "$SETUP_STATUS" = "failure" ]; then
+              exit 1
+          elif [ "$LINUX_CLI_STATUS" = "failure" ]; then
+              exit 1
+          elif [ "$MACOS_CLI_STATUS" = "failure" ]; then
+              exit 1
+          elif [ "$WINDOWS_CLI_STATUS" = "failure" ]; then
+              exit 1
+          elif [ "$WINDOWS_GUI_STATUS" = "failure" ]; then
+              exit 1
+          elif [ "$LINUX_GUI_STATUS" = "failure" ]; then
+              exit 1
+          elif [ "$MACOS_GUI_STATUS" = "failure" ]; then
+              exit 1
+          fi
+
+      - name: Login to Azure - Prod Subscription
+        uses: Azure/login@77f1b2e3fb80c0e8645114159d17008b8a2e475a
+        if: failure()
+        with:
+          creds: ${{ secrets.AZURE_PROD_KV_CREDENTIALS }}
+
+      - name: Retrieve secrets
+        id: retrieve-secrets
+        uses: Azure/get-keyvault-secrets@80ccd3fafe5662407cc2e55f202ee34bfff8c403
+        if: failure()
+        with:
+          keyvault: "bitwarden-prod-kv"
+          secrets: "devops-alerts-slack-webhook-url"
+
+      - name: Notify Slack on failure
+        uses: act10ns/slack@e4e71685b9b239384b0f676a63c32367f59c2522  # v1.2.2
+        if: failure()
+        env:
+          SLACK_WEBHOOK_URL: ${{ steps.retrieve-secrets.outputs.devops-alerts-slack-webhook-url }}
+        with:
+          status: ${{ job.status }}

.github/workflows/release.yml

@@ -1,392 +1,94 @@
+---
 name: Release
 
 on:
   workflow_dispatch:
     inputs:
-      release_tag_name_input:
-        description: "Release Tag Name <X.X.X>"
+      release_type:
+        description: 'Release Options'
         required: true
-
+        default: 'Initial Release'
+        type: choice
+        options:
+          - Initial Release
+          - Redeploy
 
 jobs:
   setup:
-    runs-on: ubuntu-latest
-    outputs:
-      package_version: ${{ steps.create_tags.outputs.package_version }}
-      tag_version: ${{ steps.create_tags.outputs.tag_version }}
-      release_upload_url: ${{ steps.create_release.outputs.upload_url }}
+    name: Setup
+    runs-on: ubuntu-20.04
     steps:
-      - name: Checkout repo
-        uses: actions/checkout@v2
-
-      - name: Create Release Vars
-        id: create_tags
+      - name: Branch check
         run: |
-          case "${RELEASE_TAG_NAME_INPUT:0:1}" in
-            v)
-              echo "RELEASE_NAME=${RELEASE_TAG_NAME_INPUT:1}" >> $GITHUB_ENV
-              echo "RELEASE_TAG_NAME=$RELEASE_TAG_NAME_INPUT" >> $GITHUB_ENV
-              echo "::set-output name=package_version::${RELEASE_TAG_NAME_INPUT:1}"
-              echo "::set-output name=tag_version::$RELEASE_TAG_NAME_INPUT"
-              ;;
-            [0-9])
-              echo "RELEASE_NAME=$RELEASE_TAG_NAME_INPUT" >> $GITHUB_ENV
-              echo "RELEASE_TAG_NAME=v$RELEASE_TAG_NAME_INPUT" >> $GITHUB_ENV
-              echo "::set-output name=package_version::$RELEASE_TAG_NAME_INPUT"
-              echo "::set-output name=tag_version::v$RELEASE_TAG_NAME_INPUT"
-              ;;
-            *)
-              exit 1
-              ;;
-          esac
-        env:
-          RELEASE_TAG_NAME_INPUT: ${{ github.event.inputs.release_tag_name_input }}
+          if [[ "$GITHUB_REF" != "refs/heads/rc" ]] && [[ "$GITHUB_REF" != "refs/heads/hotfix" ]]; then
+            echo "==================================="
+            echo "[!] Can only release from the 'rc' or 'hotfix' branches"
+            echo "==================================="
+            exit 1
+          fi
 
-      - name: Create Draft Release
-        id: create_release
-        uses: actions/create-release@v1
+      - name: Checkout repo
+        uses: actions/checkout@5a4ac9002d0be2fb38bd78e4b4dbde5606d7042f
+
+      - name: Retrieve Directory Connector release version
+        id: retrieve-version
+        run: |
+          PKG_VERSION=$(jq -r .version src/package.json)
+          echo "::set-output name=package_version::$PKG_VERSION"
+
+      - name: Check to make sure Mobile release version has been bumped
+        if: ${{ github.event.inputs.release_type == 'Initial Release' }}
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: |
+          latest_ver=$(hub release -L 1 -f '%T')
+          latest_ver=${latest_ver:1}
+          echo "Latest version: $latest_ver"
+          ver=${{ steps.retrieve-version.outputs.package_version }}
+          echo "Version: $ver"
+          if [ "$latest_ver" = "$ver" ]; then
+            echo "Version has not been bumped!"
+            exit 1
+          fi
+        shell: bash
+
+      - name: Get branch name
+        id: branch
+        run: |
+          BRANCH_NAME=$(basename ${{ github.ref }})
+          echo "::set-output name=branch-name::$BRANCH_NAME"
+
+      - name: Download all artifacts
+        uses: bitwarden/gh-actions/download-artifacts@23433be15ed6fd046ce12b6889c5184a8d9c8783
         with:
-          tag_name: ${{ env.RELEASE_TAG_NAME }}
-          release_name: ${{ env.RELEASE_NAME }}
+          workflow: build.yml
+          workflow_conclusion: success
+          branch: ${{ steps.branch.outputs.branch-name }}
+
+      - name: Create release
+        uses: ncipollo/release-action@95215a3cb6e6a1908b3c44e00b4fdb15548b1e09  # v2.8.5
+        env:
+          PKG_VERSION: ${{ steps.retrieve-version.outputs.package_version }}
+        with:
+          artifacts: "./bwdc-windows-${{ env.PKG_VERSION }}.zip,
+                      ./bwdc-macos-${{ env.PKG_VERSION }}.zip,
+                      ./bwdc-linux-${{ env.PKG_VERSION }}.zip,
+                      ./bwdc-windows-sha256-${{ env.PKG_VERSION }}.txt,
+                      ./bwdc-macos-sha256-${{ env.PKG_VERSION }}.txt,
+                      ./bwdc-linux-sha256-${{ env.PKG_VERSION }}.txt,
+                      ./Bitwarden-Connector-Portable-${{ env.PKG_VERSION }}.exe,
+                      ./Bitwarden-Connector-Installer-${{ env.PKG_VERSION }}.exe,
+                      ./Bitwarden-Connector-Installer-${{ env.PKG_VERSION }}.exe.blockmap,
+                      ./Bitwarden-Connector-${{ env.PKG_VERSION }}-x86_64.AppImage,
+                      ./Bitwarden-Connector-${{ env.PKG_VERSION }}-mac.zip,
+                      ./Bitwarden-Connector-${{ env.PKG_VERSION }}.dmg,
+                      ./Bitwarden-Connector-${{ env.PKG_VERSION }}.dmg.blockmap,
+                      ./latest-linux.yml,
+                      ./latest-mac.yml,
+                      ./latest.yml"
+          commit: ${{ github.sha }}
+          tag: v${{ env.PKG_VERSION }}
+          name: Version ${{ env.PKG_VERSION }}
+          body: "<insert release notes here>"
+          token: ${{ secrets.GITHUB_TOKEN }}
           draft: true
-          prerelease: false
-
-
-  cli:
-    runs-on: windows-latest
-    needs: setup
-    env:
-      PACKAGE_VERSION: ${{ needs.setup.outputs.package_version }}
-    steps:
-      - name: Checkout repo
-        uses: actions/checkout@v2
-
-      - name: Setup Windows builder
-        run: |
-          choco install checksum --no-progress
-          choco install reshack --no-progress
-
-      - name: Set up Node
-        uses: actions/setup-node@v1
-        with:
-          node-version: '10.x'
-
-      - name: Set VER_INFO
-        run: |
-          echo "WIN_PKG=$env:WIN_PKG" | Out-File -FilePath $env:GITHUB_ENV -Encoding utf8 -Append
-        env:
-          WIN_PKG: C:\Users\runneradmin\.pkg-cache\v2.5\fetched-v10.4.1-win-x64
-
-      - name: get pkg-fetch
-        shell: pwsh
-        run: |
-          cd $HOME
-          $fetchedUrl = "https://github.com/vercel/pkg-fetch/releases/download/v2.5/uploaded-v2.5-node-v10.4.1-win-x64"
-
-          New-Item -ItemType directory -Path ./.pkg-cache
-          New-Item -ItemType directory -Path ./.pkg-cache/v2.5
-          Invoke-RestMethod -Uri $fetchedUrl -OutFile "./.pkg-cache/v2.5/fetched-v10.4.1-win-x64"
-        env:
-          WIN_PKG: C:\Users\runneradmin\.pkg-cache\v2.5\fetched-v10.4.1-win-x64
-
-      - name: Keytar
-        shell: pwsh
-        run: |
-          $keytarVersion = (Get-Content -Raw -Path ./src/package.json | ConvertFrom-Json).dependencies.keytar
-          $nodeModVersion = node -e "console.log(process.config.variables.node_module_version)"
-          $keytarTar = "keytar-v${keytarVersion}-node-v${nodeModVersion}-{0}-x64.tar"
-          $keytarTarGz = "${keytarTar}.gz"
-          $keytarUrl = "https://github.com/atom/node-keytar/releases/download/v${keytarVersion}/${keytarTarGz}"
-
-          New-Item -ItemType directory -Path ./keytar/macos | Out-Null
-          New-Item -ItemType directory -Path ./keytar/linux | Out-Null
-          New-Item -ItemType directory -Path ./keytar/windows | Out-Null
-
-          Invoke-RestMethod -Uri $($keytarUrl -f "darwin") -OutFile "./keytar/macos/$($keytarTarGz -f "darwin")"
-          Invoke-RestMethod -Uri $($keytarUrl -f "linux") -OutFile "./keytar/linux/$($keytarTarGz -f "linux")"
-          Invoke-RestMethod -Uri $($keytarUrl -f "win32") -OutFile "./keytar/windows/$($keytarTarGz -f "win32")"
-
-          7z e "./keytar/macos/$($keytarTarGz -f "darwin")" -o"./keytar/macos"
-          7z e "./keytar/linux/$($keytarTarGz -f "linux")" -o"./keytar/linux"
-          7z e "./keytar/windows/$($keytarTarGz -f "win32")" -o"./keytar/windows"
-
-          7z e "./keytar/macos/$($keytarTar -f "darwin")" -o"./keytar/macos"
-          7z e "./keytar/linux/$($keytarTar -f "linux")" -o"./keytar/linux"
-          7z e "./keytar/windows/$($keytarTar -f "win32")" -o"./keytar/windows"
-
-      - name: Setup Version Info
-        shell: pwsh
-        run: ./scripts/make-versioninfo.ps1
-
-      - name: Resource Hacker
-        shell: cmd
-        run: |
-          set PATH=%PATH%;C:\Program Files (x86)\Resource Hacker
-          ResourceHacker -open %WIN_PKG% -save %WIN_PKG% -action delete -mask ICONGROUP,1,
-          ResourceHacker -open version-info.rc -save version-info.res -action compile
-          ResourceHacker -open %WIN_PKG% -save %WIN_PKG% -action addoverwrite -resource version-info.res
-
-      - name: Install
-        run: npm install
-
-      - name: Package CLI
-        run: npm run dist:cli
-
-      - name: Zip
-        shell: cmd
-        run: |
-          7z a ./dist-cli/bwdc-windows-%PACKAGE_VERSION%.zip ./dist-cli/windows/bwdc.exe ./keytar/windows/keytar.node
-          7z a ./dist-cli/bwdc-macos-%PACKAGE_VERSION%.zip ./dist-cli/macos/bwdc ./keytar/macos/keytar.node
-          7z a ./dist-cli/bwdc-linux-%PACKAGE_VERSION%.zip ./dist-cli/linux/bwdc ./keytar/linux/keytar.node
-
-      - name: Version Test
-        run: |
-          Expand-Archive -Path "./dist-cli/bwdc-windows-${env:PACKAGE_VERSION}.zip" -DestinationPath "./test/windows"
-          $testVersion = Invoke-Expression '& ./test/windows/bwdc.exe -v'
-          echo "version: $env:PACKAGE_VERSION"
-          echo "testVersion: $testVersion"
-          if($testVersion -ne $env:PACKAGE_VERSION) {
-            Throw "Version test failed."
-          }
-
-      - name: Create checksums
-        run: |
-          checksum -f="./dist-cli/bwdc-windows-${env:PACKAGE_VERSION}.zip" `
-            -t sha256 | Out-File ./dist-cli/bwdc-windows-sha256-${env:PACKAGE_VERSION}.txt
-          checksum -f="./dist-cli/bwdc-macos-${env:PACKAGE_VERSION}.zip" `
-            -t sha256 | Out-File ./dist-cli/bwdc-macos-sha256-${env:PACKAGE_VERSION}.txt
-          checksum -f="./dist-cli/bwdc-linux-${env:PACKAGE_VERSION}.zip" `
-            -t sha256 | Out-File ./dist-cli/bwdc-linux-sha256-${env:PACKAGE_VERSION}.txt
-
-      - name: upload windows zip release asset
-        uses: actions/upload-release-asset@v1
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        with:
-          upload_url: ${{ needs.setup.outputs.release_upload_url }}
-          asset_path: ./dist-cli/bwdc-windows-${{ env.PACKAGE_VERSION }}.zip
-          asset_name: bwdc-windows-${{ env.PACKAGE_VERSION }}.zip
-          asset_content_type: application/zip
-
-      - name: upload macos zip release asset
-        uses: actions/upload-release-asset@v1
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        with:
-          upload_url: ${{ needs.setup.outputs.release_upload_url }}
-          asset_path: ./dist-cli/bwdc-macos-${{ env.PACKAGE_VERSION }}.zip
-          asset_name: bwdc-macos-${{ env.PACKAGE_VERSION }}.zip
-          asset_content_type: application/zip
-
-      - name: upload linux zip release asset
-        uses: actions/upload-release-asset@v1
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        with:
-          upload_url: ${{ needs.setup.outputs.release_upload_url }}
-          asset_path: ./dist-cli/bwdc-linux-${{ env.PACKAGE_VERSION }}.zip
-          asset_name: bwdc-linux-${{ env.PACKAGE_VERSION }}.zip
-          asset_content_type: application/zip
-
-      - name: upload windows checksum release asset
-        uses: actions/upload-release-asset@v1
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        with:
-          upload_url: ${{ needs.setup.outputs.release_upload_url }}
-          asset_path: ./dist-cli/bwdc-windows-sha256-${{ env.PACKAGE_VERSION }}.txt
-          asset_name: bwdc-windows-sha256-${{ env.PACKAGE_VERSION }}.txt
-          asset_content_type: text/plain
-
-      - name: upload macos checksum release asset
-        uses: actions/upload-release-asset@v1
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        with:
-          upload_url: ${{ needs.setup.outputs.release_upload_url }}
-          asset_path: ./dist-cli/bwdc-macos-sha256-${{ env.PACKAGE_VERSION }}.txt
-          asset_name: bwdc-macos-sha256-${{ env.PACKAGE_VERSION }}.txt
-          asset_content_type: text/plain
-
-      - name: upload linux checksum release asset
-        uses: actions/upload-release-asset@v1
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        with:
-          upload_url: ${{ needs.setup.outputs.release_upload_url }}
-          asset_path: ./dist-cli/bwdc-linux-sha256-${{ env.PACKAGE_VERSION }}.txt
-          asset_name: bwdc-linux-sha256-${{ env.PACKAGE_VERSION }}.txt
-          asset_content_type: text/plain
-
-
-  windows-gui:
-    runs-on: windows-latest
-    needs: setup
-    env:
-      PACKAGE_VERSION: ${{ needs.setup.outputs.package_version }}
-    steps:
-      - name: Set up dotnet
-        uses: actions/setup-dotnet@v1
-        with:
-          dotnet-version: "3.1.x"
-
-      - name: Set up Node
-        uses: actions/setup-node@v1
-        with:
-          node-version: '10.x'
-
-      - name: Set Node options
-        run: echo "NODE_OPTIONS=--max_old_space_size=4096" | Out-File -FilePath $env:GITHUB_ENV -Encoding utf8 -Append
-        shell: pwsh
-
-      - name: Print environment
-        run: |
-          node --version
-          npm --version
-          dotnet --version
-
-      - name: Install AST
-        shell: pwsh
-        run: |
-          cd $HOME
-          git clone https://github.com/vcsjones/AzureSignTool.git
-          cd AzureSignTool
-          $latest_head = $(git rev-parse HEAD)[0..9] -join ""
-          $latest_version = "0.0.0-g$latest_head"
-          Write-Host "--------"
-          Write-Host "git commit - $(git rev-parse HEAD)"
-          Write-Host "latest_head - $latest_head"
-          Write-Host "PACKAGE VERSION TO BUILD - $latest_version"
-          Write-Host "--------"
-          dotnet restore
-          dotnet pack --output ./nupkg
-          dotnet tool install --global --ignore-failed-sources --add-source ./nupkg --version $latest_version azuresigntool
-          cd $HOME
-
-      - name: Checkout repo
-        uses: actions/checkout@v2
-
-      - name: Install Node dependencies
-        run: npm install
-
-      - name: Run linter
-        run: npm run lint
-
-      - name: npm rebuild
-        run: npm run rebuild
-
-      - name: Build & Sign
-        run: |
-          npm run publish:win
-        env:
-          ELECTRON_BUILDER_SIGN: 1
-          SIGNING_VAULT_URL: ${{ secrets.SIGNING_VAULT_URL }}
-          SIGNING_CLIENT_ID: ${{ secrets.SIGNING_CLIENT_ID }}
-          SIGNING_TENANT_ID: ${{ secrets.SIGNING_TENANT_ID }}
-          SIGNING_CLIENT_SECRET: ${{ secrets.SIGNING_CLIENT_SECRET }}
-          SIGNING_CERT_NAME: ${{ secrets.SIGNING_CERT_NAME }}
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-
-
-  linux:
-    runs-on: ubuntu-latest
-    needs: setup
-    env:
-      PACKAGE_VERSION: ${{ needs.setup.outputs.package_version }}
-    steps:
-      - name: Set up Node
-        uses: actions/setup-node@v1
-        with:
-          node-version: '10.x'
-
-      - name: Set Node options
-        run: echo "NODE_OPTIONS=--max_old_space_size=4096" >> $GITHUB_ENV
-
-      - name: Set up environment
-        run: |
-          sudo apt-get update
-          sudo apt-get -y install pkg-config libxss-dev libsecret-1-dev 
-          sudo apt-get -y install rpm
-
-      - name: Checkout repo
-        uses: actions/checkout@v2
-
-      - name: Set PACKAGE_VERSION
-        shell: pwsh
-        run: |
-          $env:pkgVersion = (Get-Content -Raw -Path ./src/package.json | ConvertFrom-Json).version
-          echo "PACKAGE_VERSION=$env:pkgVersion" | Out-File -FilePath $env:GITHUB_ENV -Encoding utf8 -Append
-          echo "version: $env:pkgVersion"
-
-      - name: npm install
-        run: npm install
-
-      - name: npm rebuild
-        run: npm run rebuild
-
-      - name: npm package
-        run: npm run publish:lin
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-
-
-  macos:
-    runs-on: macos-latest
-    needs: setup
-    env:
-      PACKAGE_VERSION: ${{ needs.setup.outputs.package_version }}
-    steps:
-      - name: Set up Node
-        uses: actions/setup-node@v1
-        with:
-          node-version: '10.x'
-
-      - name: Set Node options
-        run: echo "NODE_OPTIONS=--max_old_space_size=4096" >> $GITHUB_ENV
-
-      - name: Print environment
-        run: |
-          node --version
-          npm --version
-          Write-Output "GitHub ref: $env:GITHUB_REF"
-          Write-Output "GitHub event: $env:GITHUB_EVENT"
-        shell: pwsh
-        env:
-          GITHUB_REF: ${{ github.ref }}
-          GITHUB_EVENT: ${{ github.event_name }}
-
-      - name: Checkout repo
-        uses: actions/checkout@v2
-
-      - name: Decrypt secrets
-        run: ./.github/scripts/macos/decrypt-secrets.ps1
-        shell: pwsh
-        env:
-          DECRYPT_FILE_PASSWORD: ${{ secrets.DECRYPT_FILE_PASSWORD }}
-
-      - name: Set up keychain
-        run: ./.github/scripts/macos/setup-keychain.ps1
-        shell: pwsh
-        env:
-          KEYCHAIN_PASSWORD: ${{ secrets.KEYCHAIN_PASSWORD }}
-          DEVID_CERT_PASSWORD: ${{ secrets.DEVID_CERT_PASSWORD }}
-          MACDEV_CERT_PASSWORD: ${{ secrets.MACDEV_CERT_PASSWORD }}
-
-      - name: Load package version
-        run: ./.github/scripts/load-version.ps1
-        shell: pwsh
-
-      - name: Install Node dependencies
-        run: npm install
-
-      - name: Run linter
-        run: npm run lint
-
-      - name: Build application (dist)
-        run: npm run publish:mac
-        env:
-          APPLE_ID_USERNAME: ${{ secrets.APPLE_ID_USERNAME }}
-          APPLE_ID_PASSWORD: ${{ secrets.APPLE_ID_PASSWORD }}
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

.github/workflows/version-bump.yml

@@ -0,0 +1,65 @@
+---
+name: Version Bump
+
+on:
+  workflow_dispatch:
+    inputs:
+      version_number:
+        description: "New Version"
+        required: true
+
+jobs:
+  bump_version:
+    name: "Create version_bump_${{ github.event.inputs.version_number }} branch"
+    runs-on: ubuntu-20.04
+    steps:
+      - name: Checkout Branch
+        uses: actions/checkout@ec3a7ce113134d7a93b817d10a8272cb61118579
+
+      - name: Create Version Branch
+        run: |
+          git switch -c version_bump_${{ github.event.inputs.version_number }}
+          git push -u origin version_bump_${{ github.event.inputs.version_number }}
+
+      - name: Checkout Version Branch
+        uses: actions/checkout@ec3a7ce113134d7a93b817d10a8272cb61118579
+        with:
+          ref: version_bump_${{ github.event.inputs.version_number }}
+
+      - name: Bump Version - Package
+        uses: bitwarden/gh-actions/version-bump@03ad9a873c39cdc95dd8d77dbbda67f84db43945
+        with:
+          version: ${{ github.event.inputs.version_number }}
+          file_path: "./src/package.json"
+
+      - name: Commit files
+        run: |
+          git config --local user.email "41898282+github-actions[bot]@users.noreply.github.com"
+          git config --local user.name "github-actions[bot]"
+          git commit -m "Bumped version to ${{ github.event.inputs.version_number }}" -a
+
+      - name: Push changes
+        run: git push -u origin version_bump_${{ github.event.inputs.version_number }}
+
+      - name: Create Version PR
+        env:
+          PR_BRANCH: "version_bump_${{ github.event.inputs.version_number }}"
+          GITHUB_TOKEN: "${{ secrets.GITHUB_TOKEN }}"
+          BASE_BRANCH: master
+          TITLE: "Bump version to ${{ github.event.inputs.version_number }}"
+        run: |
+          gh pr create --title "$TITLE" \
+            --base "$BASE" \
+            --head "$PR_BRANCH" \
+            --label "version update" \
+            --label "automated pr" \
+            --body "
+              ## Type of change
+              - [ ] Bug fix
+              - [ ] New feature development
+              - [ ] Tech debt (refactoring, code cleanup, dependency upgrades, etc)
+              - [ ] Build/deploy pipeline (DevOps)
+              - [X] Other
+              
+              ## Objective
+              Automated version bump to ${{ github.event.inputs.version_number }}"

.husky/.gitignore

@@ -0,0 +1 @@
+_

.husky/pre-commit

@@ -0,0 +1,4 @@
+#!/bin/sh
+. "$(dirname "$0")/_/husky.sh"
+
+npx lint-staged

.prettierignore

@@ -0,0 +1,11 @@
+# Build directories
+build
+dist
+
+jslib
+
+# External libraries / auto synced locales
+src/locales
+
+# Github Workflows
+.github/workflows 

.prettierrc.json

@@ -0,0 +1,3 @@
+{
+  "printWidth": 100
+}

.vscode/launch.json

@@ -1,48 +1,40 @@
 {
   "version": "0.2.0",
   "configurations": [
-      {
-          "type": "node",
-          "request": "launch",
-          "name": "Electron: Main",
-          "protocol": "inspector",
-          "cwd": "${workspaceRoot}/build",
-          "runtimeArgs": [
-              "--remote-debugging-port=9223",
-              "."
-          ],
-          "windows": {
-              "runtimeExecutable": "${workspaceFolder}/node_modules/.bin/electron.cmd"
-          },
-          "sourceMaps": true
+    {
+      "type": "node",
+      "request": "launch",
+      "name": "Electron: Main",
+      "protocol": "inspector",
+      "cwd": "${workspaceRoot}/build",
+      "runtimeArgs": ["--remote-debugging-port=9223", "."],
+      "windows": {
+        "runtimeExecutable": "${workspaceFolder}/node_modules/.bin/electron.cmd"
       },
-      {
-          "name": "Electron: Renderer",
-          "type": "chrome",
-          "request": "attach",
-          "port": 9223,
-          "webRoot": "${workspaceFolder}/build",
-          "sourceMaps": true
+      "sourceMaps": true
     },
     {
-        "type": "node",
-        "request": "launch",
-        "name": "Debug CLI",
-        "protocol": "inspector",
-        "cwd": "${workspaceFolder}",
-        "program": "${workspaceFolder}/build-cli/bwdc.js",
-        "args": [
-            "sync"
-        ]
+      "name": "Electron: Renderer",
+      "type": "chrome",
+      "request": "attach",
+      "port": 9223,
+      "webRoot": "${workspaceFolder}/build",
+      "sourceMaps": true
+    },
+    {
+      "type": "node",
+      "request": "launch",
+      "name": "Debug CLI",
+      "protocol": "inspector",
+      "cwd": "${workspaceFolder}",
+      "program": "${workspaceFolder}/build-cli/bwdc.js",
+      "args": ["sync"]
     }
   ],
   "compounds": [
-      {
-          "name": "Electron: All",
-          "configurations": [
-              "Electron: Main",
-              "Electron: Renderer"
-          ]
-      }
+    {
+      "name": "Electron: All",
+      "configurations": ["Electron: Main", "Electron: Renderer"]
+    }
   ]
 }

README.md

@@ -6,6 +6,7 @@
 The Bitwarden Directory Connector is a a desktop application used to sync your Bitwarden enterprise organization to an existing directory of users and groups.
 
 Supported directories:
+
 - Active Directory
 - Any other LDAP-based directory
 - Azure Active Directory
@@ -47,7 +48,7 @@ We provide detailed documentation and examples for using the Directory Connector
 
 **Requirements**
 
-- [Node.js](https://nodejs.org/)
+- [Node.js](https://nodejs.org) v16.13.1 (LTS)
 - Windows users: To compile the native node modules used in the app you will need the Visual C++ toolset, available through the standard Visual Studio installer (recommended) or by installing [`windows-build-tools`](https://github.com/felixrieseberg/windows-build-tools) through `npm`. See more at [Compiling native Addon modules](https://github.com/Microsoft/nodejs-guidelines/blob/master/windows-environment.md#compiling-native-addon-modules).
 
 **Run the app**
@@ -78,3 +79,23 @@ node ./build-cli/bwdc.js --help
 Code contributions are welcome! Please commit any pull requests against the `master` branch. Learn more about how to contribute by reading the [`CONTRIBUTING.md`](CONTRIBUTING.md) file.
 
 Security audits and feedback are welcome. Please open an issue or email us privately if the report is sensitive in nature. You can read our security policy in the [`SECURITY.md`](SECURITY.md) file.
+
+### Prettier
+
+We recently migrated to using Prettier as code formatter. All previous branches will need to updated to avoid large merge conflicts using the following steps:
+
+1. Check out your local Branch
+2. Run `git merge 225073aa335d33ad905877b68336a9288e89ea10`
+3. Resolve any merge conflicts, commit.
+4. Run `npm run prettier`
+5. Commit
+6. Run `git merge -Xours 096196fcd512944d1c3d9c007647a1319b032639`
+7. Push
+
+#### Git blame
+
+We also recommend that you configure git to ignore the prettier revision using:
+
+```bash
+git config blame.ignoreRevsFile .git-blame-ignore-revs
+```

gulpfile.js

@@ -1,31 +0,0 @@
-const gulp = require('gulp');
-const googleWebFonts = require('gulp-google-webfonts');
-const del = require('del');
-
-const paths = {
-    cssDir: './src/css/',
-};
-
-function clean() {
-    return del([paths.cssDir]);
-}
-
-function webfonts() {
-    return gulp.src('./webfonts.list')
-        .pipe(googleWebFonts({
-            fontsDir: 'webfonts',
-            cssFilename: 'webfonts.css',
-            format: 'woff',
-        }))
-        .pipe(gulp.dest(paths.cssDir));
-}
-
-// ref: https://github.com/angular/angular/issues/22524
-function cleanupAotIssue() {
-    return del(['./node_modules/@types/uglify-js/node_modules/source-map/source-map.d.ts']);
-}
-
-exports.clean = clean;
-exports.cleanupAotIssue = cleanupAotIssue;
-exports.webfonts = gulp.series(clean, webfonts);
-exports['prebuild:renderer'] = gulp.parallel(webfonts, cleanupAotIssue);;

package.json

@@ -1,6 +1,5 @@
 {
-  "name": "bitwarden-directory-connector",
-  "productName": "Bitwarden Directory Connector",
+  "name": "@bitwarden/directory-connector",
   "description": "Sync your user directory to your Bitwarden organization.",
   "version": "0.0.0",
   "keywords": [
@@ -21,18 +20,18 @@
     "sub:update": "git submodule update --remote",
     "sub:pull": "git submodule foreach git pull origin master",
     "sub:commit": "npm run sub:pull && git commit -am \"update submodule\"",
-    "postinstall": "npm run sub:init",
+    "preinstall": "npm run sub:init",
     "symlink:win": "rm -rf ./jslib && cmd /c mklink /J .\\jslib ..\\jslib",
     "symlink:mac": "npm run symlink:lin",
     "symlink:lin": "rm -rf ./jslib && ln -s ../jslib ./jslib",
-    "rebuild": "./node_modules/.bin/electron-rebuild",
+    "rebuild": "electron-rebuild",
     "reset": "rimraf ./node_modules/keytar/* && npm install",
-    "lint": "tslint 'src/**/*.ts' || true",
+    "lint": "tslint 'src/**/*.ts' && prettier --check .",
     "lint:fix": "tslint 'src/**/*.ts' --fix",
     "build": "concurrently -n Main,Rend -c yellow,cyan \"npm run build:main\" \"npm run build:renderer\"",
     "build:main": "webpack --config webpack.main.js",
-    "build:renderer": "gulp prebuild:renderer && webpack --config webpack.renderer.js",
-    "build:renderer:watch": "gulp prebuild:renderer && webpack --config webpack.renderer.js --watch",
+    "build:renderer": "webpack --config webpack.renderer.js",
+    "build:renderer:watch": "webpack --config webpack.renderer.js --watch",
     "build:dist": "npm run reset && npm run rebuild && npm run build",
     "build:cli": "webpack --config webpack.cli.js",
     "build:cli:watch": "webpack --config webpack.cli.js --watch",
@@ -59,11 +58,17 @@
     "dist:cli:lin": "npm run build:cli:prod && npm run clean:dist:cli && npm run pack:cli:lin",
     "publish:lin": "npm run build:dist && npm run clean:dist && electron-builder --linux --x64 -p always",
     "publish:mac": "npm run build:dist && npm run clean:dist && electron-builder --mac -p always",
-    "publish:win": "npm run build:dist && npm run clean:dist && electron-builder --win --x64 --ia32 -p always -c.win.certificateSubjectName=\"8bit Solutions LLC\""
+    "publish:win": "npm run build:dist && npm run clean:dist && electron-builder --win --x64 --ia32 -p always -c.win.certificateSubjectName=\"8bit Solutions LLC\"",
+    "prettier": "prettier --write .",
+    "prepare": "husky install"
   },
   "build": {
+    "extraMetadata": {
+      "name": "bitwarden-directory-connector"
+    },
+    "productName": "Bitwarden Directory Connector",
     "appId": "com.bitwarden.directory-connector",
-    "copyright": "Copyright © 2015-2020 Bitwarden Inc.",
+    "copyright": "Copyright © 2015-2022 Bitwarden Inc.",
     "directories": {
       "buildResources": "resources",
       "output": "dist",
@@ -132,95 +137,79 @@
     }
   },
   "devDependencies": {
-    "@angular/compiler-cli": "^9.1.12",
+    "@angular/compiler-cli": "^12.2.13",
     "@microsoft/microsoft-graph-types": "^1.4.0",
-    "@ngtools/webpack": "^9.1.12",
-    "@types/commander": "^2.12.2",
-    "@types/form-data": "^2.2.1",
-    "@types/inquirer": "^0.0.43",
-    "@types/ldapjs": "^1.0.3",
-    "@types/lowdb": "^1.0.5",
-    "@types/lunr": "^2.3.3",
-    "@types/node": "^10.17.28",
-    "@types/node-fetch": "^2.5.10",
-    "@types/node-forge": "^0.9.7",
-    "@types/papaparse": "^5.2.0",
+    "@ngtools/webpack": "^12.2.13",
+    "@types/ldapjs": "^1.0.10",
+    "@types/node": "^16.11.12",
     "@types/proper-lockfile": "^4.1.1",
-    "@types/semver": "^5.5.0",
-    "@types/source-map": "0.5.2",
-    "@types/webcrypto": "^0.0.28",
-    "@types/webpack": "^4.4.11",
-    "@types/zxcvbn": "4.4.0",
-    "clean-webpack-plugin": "^0.1.19",
-    "concurrently": "^4.0.1",
-    "copy-webpack-plugin": "^5.1.1",
-    "cross-env": "^5.2.0",
-    "css-loader": "^1.0.0",
-    "del": "^3.0.0",
-    "electron": "11.3.0",
-    "electron-builder": "22.9.1",
-    "electron-notarize": "^1.0.0",
-    "electron-rebuild": "^2.3.5",
+    "clean-webpack-plugin": "^4.0.0",
+    "concurrently": "^6.0.2",
+    "copy-webpack-plugin": "^10.0.0",
+    "cross-env": "^7.0.3",
+    "css-loader": "^6.5.1",
+    "electron-builder": "^22.14.5",
+    "electron-notarize": "^1.1.1",
+    "electron-rebuild": "^3.2.5",
     "electron-reload": "^1.5.0",
-    "file-loader": "^2.0.0",
-    "font-awesome": "4.7.0",
-    "gulp": "^4.0.0",
-    "gulp-google-webfonts": "^2.0.0",
-    "html-loader": "^0.5.5",
-    "html-webpack-plugin": "^3.2.0",
-    "mini-css-extract-plugin": "^0.9.0",
-    "node-abi": "^2.9.0",
-    "node-loader": "^0.6.0",
-    "node-sass": "^4.13.1",
-    "pkg": "4.3.8",
-    "rimraf": "^2.6.2",
-    "sass-loader": "^7.1.0",
-    "ts-loader": "^7.0.5",
-    "tslint": "^5.12.1",
+    "html-loader": "^3.0.1",
+    "html-webpack-plugin": "^5.5.0",
+    "husky": "^7.0.4",
+    "lint-staged": "^12.1.3",
+    "mini-css-extract-plugin": "^2.4.5",
+    "node-loader": "^2.0.0",
+    "pkg": "^5.5.1",
+    "prebuild-install": "^5.0.0",
+    "prettier": "^2.5.1",
+    "rimraf": "^3.0.2",
+    "sass": "^1.32.11",
+    "sass-loader": "^12.4.0",
+    "tapable": "^1.1.3",
+    "ts-loader": "^9.2.5",
+    "tsconfig-paths-webpack-plugin": "^3.5.1",
+    "tslint": "~6.1.0",
     "tslint-loader": "^3.5.4",
-    "typescript": "3.8.3",
-    "webpack": "^4.29.0",
-    "webpack-cli": "^3.2.1",
-    "webpack-merge": "^4.2.1",
-    "webpack-node-externals": "^1.7.2"
+    "typescript": "4.3.5",
+    "webpack": "^5.64.4",
+    "webpack-cli": "^4.9.1",
+    "webpack-merge": "^5.8.0",
+    "webpack-node-externals": "^3.0.0"
   },
   "dependencies": {
-    "@angular/animations": "9.1.12",
-    "@angular/common": "9.1.12",
-    "@angular/compiler": "9.1.12",
-    "@angular/core": "9.1.12",
-    "@angular/forms": "9.1.12",
-    "@angular/platform-browser": "9.1.12",
-    "@angular/platform-browser-dynamic": "9.1.12",
-    "@angular/router": "9.1.12",
-    "@angular/upgrade": "9.1.12",
-    "@microsoft/microsoft-graph-client": "1.2.0",
-    "angular2-toaster": "8.0.0",
-    "big-integer": "1.6.48",
-    "bootstrap": "4.3.1",
-    "browser-hrtime": "^1.1.8",
-    "chalk": "2.4.1",
-    "commander": "7.0.0",
-    "core-js": "2.6.2",
+    "@angular/animations": "^12.2.13",
+    "@angular/cdk": "^12.2.13",
+    "@angular/common": "^12.2.13",
+    "@angular/compiler": "^12.2.13",
+    "@angular/core": "^12.2.13",
+    "@angular/forms": "^12.2.13",
+    "@angular/platform-browser": "^12.2.13",
+    "@angular/platform-browser-dynamic": "^12.2.13",
+    "@angular/router": "^12.2.13",
+    "@bitwarden/jslib-angular": "file:jslib/angular",
+    "@bitwarden/jslib-common": "file:jslib/common",
+    "@bitwarden/jslib-electron": "file:jslib/electron",
+    "@bitwarden/jslib-node": "file:jslib/node",
+    "@microsoft/microsoft-graph-client": "^2.2.1",
+    "bootstrap": "^4.6.0",
+    "chalk": "^4.1.1",
+    "commander": "^7.2.0",
+    "core-js": "^3.11.0",
     "duo_web_sdk": "git+https://github.com/duosecurity/duo_web_sdk.git",
-    "electron-log": "4.3.0",
-    "electron-store": "6.0.1",
-    "electron-updater": "4.3.5",
-    "form-data": "2.3.2",
-    "googleapis": "43.0.0",
-    "https-proxy-agent": "5.0.0",
-    "inquirer": "6.2.0",
-    "keytar": "7.3.0",
-    "ldapjs": "git+https://git@github.com/kspearrin/node-ldapjs.git",
-    "lowdb": "1.0.0",
-    "lunr": "2.3.3",
-    "node-fetch": "2.6.1",
-    "node-forge": "0.10.0",
-    "open": "7.1.0",
+    "form-data": "^4.0.0",
+    "googleapis": "^73.0.0",
+    "inquirer": "8.0.0",
+    "ldapjs": "2.3.1",
+    "lunr": "^2.3.9",
+    "ngx-toastr": "14.1.4",
+    "open": "^8.0.6",
     "proper-lockfile": "^4.1.2",
-    "rxjs": "6.6.2",
-    "tslib": "^2.0.1",
-    "zone.js": "0.10.3",
-    "zxcvbn": "4.4.2"
+    "rxjs": "^7.4.0"
+  },
+  "engines": {
+    "node": "~16",
+    "npm": "~8"
+  },
+  "lint-staged": {
+    "*": "prettier --ignore-unknown --write"
   }
 }

scripts/make-versioninfo.ps1

@@ -1,33 +0,0 @@
-$major,$minor,$patch = $env:PACKAGE_VERSION.split('.')
-
-$versionInfo = @"
-
-1 VERSIONINFO
-FILEVERSION $major,$minor,$patch,0
-PRODUCTVERSION $major,$minor,$patch,0
-FILEOS 0x40004
-FILETYPE 0x1
-{
-BLOCK "StringFileInfo"
-{
-	BLOCK "040904b0"
-	{
-		VALUE "CompanyName", "Bitwarden Inc."
-		VALUE "ProductName", "Bitwarden"
-		VALUE "FileDescription", "Bitwarden Directory Connector CLI"
-		VALUE "FileVersion", "$env:PACKAGE_VERSION"
-		VALUE "ProductVersion", "$env:PACKAGE_VERSION"
-		VALUE "OriginalFilename", "bwdc.exe"
-		VALUE "InternalName", "bwdc"
-		VALUE "LegalCopyright", "Copyright Bitwarden Inc."
-	}
-}
-
-BLOCK "VarFileInfo"
-{
-	VALUE "Translation", 0x0409 0x04B0  
-}
-}
-"@
-
-$versionInfo | Out-File ./version-info.rc

scripts/notarize.js

@@ -1,18 +1,18 @@
-require('dotenv').config();
-const { notarize } = require('electron-notarize');
+require("dotenv").config();
+const { notarize } = require("electron-notarize");
 
 exports.default = async function notarizing(context) {
-    const { electronPlatformName, appOutDir } = context;
-    if (electronPlatformName !== 'darwin') {
-        return;
-    }
-    const appleId = process.env.APPLE_ID_USERNAME || process.env.APPLEID;
-    const appleIdPassword = process.env.APPLE_ID_PASSWORD || `@keychain:AC_PASSWORD`;
-    const appName = context.packager.appInfo.productFilename;
-    return await notarize({
-        appBundleId: 'com.bitwarden.directory-connector',
-        appPath: `${appOutDir}/${appName}.app`,
-        appleId: appleId,
-        appleIdPassword: appleIdPassword,
-    });
+  const { electronPlatformName, appOutDir } = context;
+  if (electronPlatformName !== "darwin") {
+    return;
+  }
+  const appleId = process.env.APPLE_ID_USERNAME || process.env.APPLEID;
+  const appleIdPassword = process.env.APPLE_ID_PASSWORD || `@keychain:AC_PASSWORD`;
+  const appName = context.packager.appInfo.productFilename;
+  return await notarize({
+    appBundleId: "com.bitwarden.directory-connector",
+    appPath: `${appOutDir}/${appName}.app`,
+    appleId: appleId,
+    appleIdPassword: appleIdPassword,
+  });
 };

scripts/sign.js

@@ -1,22 +1,19 @@
-exports.default = async function(configuration) {
-  if (
-    parseInt(process.env.ELECTRON_BUILDER_SIGN) === 1 && 
-    configuration.path.slice(-4) == ".exe"
-  ) {
-    console.log(`[*] Signing file: ${configuration.path}`)
+exports.default = async function (configuration) {
+  if (parseInt(process.env.ELECTRON_BUILDER_SIGN) === 1 && configuration.path.slice(-4) == ".exe") {
+    console.log(`[*] Signing file: ${configuration.path}`);
     require("child_process").execSync(
       `azuresigntool sign ` +
-      `-kvu ${process.env.SIGNING_VAULT_URL} ` +
-      `-kvi ${process.env.SIGNING_CLIENT_ID} ` +
-      `-kvt ${process.env.SIGNING_TENANT_ID} ` +
-      `-kvs ${process.env.SIGNING_CLIENT_SECRET} ` +
-      `-kvc ${process.env.SIGNING_CERT_NAME} ` +
-      `-fd ${configuration.hash} ` +
-      `-du ${configuration.site} ` +
-      `-tr http://timestamp.digicert.com ` +
-      `"${configuration.path}"`,
+        `-kvu ${process.env.SIGNING_VAULT_URL} ` +
+        `-kvi ${process.env.SIGNING_CLIENT_ID} ` +
+        `-kvt ${process.env.SIGNING_TENANT_ID} ` +
+        `-kvs ${process.env.SIGNING_CLIENT_SECRET} ` +
+        `-kvc ${process.env.SIGNING_CERT_NAME} ` +
+        `-fd ${configuration.hash} ` +
+        `-du ${configuration.site} ` +
+        `-tr http://timestamp.digicert.com ` +
+        `"${configuration.path}"`,
       {
-        stdio: "inherit"
+        stdio: "inherit",
       }
     );
   }

src-cli/package.json

@@ -1,24 +1,24 @@
 {
-  "name": "bitwarden-directory-connector",
+  "name": "@bitwarden/directory-connector",
   "productName": "Bitwarden Directory Connector",
   "description": "Sync your user directory to your Bitwarden organization.",
-  "version": "2.9.0",
+  "version": "2.9.5",
   "author": "Bitwarden Inc. <hello@bitwarden.com> (https://bitwarden.com)",
   "homepage": "https://bitwarden.com",
   "license": "GPL-3.0",
   "main": "main.js",
   "repository": {
-      "type": "git",
-      "url": "https://github.com/bitwarden/directory-connector"
+    "type": "git",
+    "url": "https://github.com/bitwarden/directory-connector"
   },
   "bin": {
-      "bwdc": "../build-cli/bwdc.js"
+    "bwdc": "../build-cli/bwdc.js"
   },
   "pkg": {
-      "assets": "../build-cli/**/*"
+    "assets": "../build-cli/**/*"
   },
   "dependencies": {
-      "browser-hrtime": "^1.1.8",
-      "keytar": "7.3.0"
+    "browser-hrtime": "^1.1.8",
+    "keytar": "^7.7.0"
   }
 }

src/abstractions/state.service.ts

@@ -0,0 +1,68 @@
+import { StateService as BaseStateServiceAbstraction } from "jslib-common/abstractions/state.service";
+
+import { StorageOptions } from "jslib-common/models/domain/storageOptions";
+
+import { DirectoryType } from "src/enums/directoryType";
+
+import { Account } from "src/models/account";
+import { AzureConfiguration } from "src/models/azureConfiguration";
+import { GSuiteConfiguration } from "src/models/gsuiteConfiguration";
+import { LdapConfiguration } from "src/models/ldapConfiguration";
+import { OktaConfiguration } from "src/models/oktaConfiguration";
+import { OneLoginConfiguration } from "src/models/oneLoginConfiguration";
+import { SyncConfiguration } from "src/models/syncConfiguration";
+
+export abstract class StateService extends BaseStateServiceAbstraction<Account> {
+  getDirectory: <IConfiguration>(type: DirectoryType) => Promise<IConfiguration>;
+  setDirectory: (
+    type: DirectoryType,
+    config:
+      | LdapConfiguration
+      | GSuiteConfiguration
+      | AzureConfiguration
+      | OktaConfiguration
+      | OneLoginConfiguration
+  ) => Promise<any>;
+  getLdapKey: (options?: StorageOptions) => Promise<string>;
+  setLdapKey: (value: string, options?: StorageOptions) => Promise<void>;
+  getGsuiteKey: (options?: StorageOptions) => Promise<string>;
+  setGsuiteKey: (value: string, options?: StorageOptions) => Promise<void>;
+  getAzureKey: (options?: StorageOptions) => Promise<string>;
+  setAzureKey: (value: string, options?: StorageOptions) => Promise<void>;
+  getOktaKey: (options?: StorageOptions) => Promise<string>;
+  setOktaKey: (value: string, options?: StorageOptions) => Promise<void>;
+  getOneLoginKey: (options?: StorageOptions) => Promise<string>;
+  setOneLoginKey: (value: string, options?: StorageOptions) => Promise<void>;
+  getLdapConfiguration: (options?: StorageOptions) => Promise<LdapConfiguration>;
+  setLdapConfiguration: (value: LdapConfiguration, options?: StorageOptions) => Promise<void>;
+  getGsuiteConfiguration: (options?: StorageOptions) => Promise<GSuiteConfiguration>;
+  setGsuiteConfiguration: (value: GSuiteConfiguration, options?: StorageOptions) => Promise<void>;
+  getAzureConfiguration: (options?: StorageOptions) => Promise<AzureConfiguration>;
+  setAzureConfiguration: (value: AzureConfiguration, options?: StorageOptions) => Promise<void>;
+  getOktaConfiguration: (options?: StorageOptions) => Promise<OktaConfiguration>;
+  setOktaConfiguration: (value: OktaConfiguration, options?: StorageOptions) => Promise<void>;
+  getOneLoginConfiguration: (options?: StorageOptions) => Promise<OneLoginConfiguration>;
+  setOneLoginConfiguration: (
+    value: OneLoginConfiguration,
+    options?: StorageOptions
+  ) => Promise<void>;
+  getOrganizationId: (options?: StorageOptions) => Promise<string>;
+  setOrganizationId: (value: string, options?: StorageOptions) => Promise<void>;
+  getSync: (options?: StorageOptions) => Promise<SyncConfiguration>;
+  setSync: (value: SyncConfiguration, options?: StorageOptions) => Promise<void>;
+  getDirectoryType: (options?: StorageOptions) => Promise<DirectoryType>;
+  setDirectoryType: (value: DirectoryType, options?: StorageOptions) => Promise<void>;
+  getUserDelta: (options?: StorageOptions) => Promise<string>;
+  setUserDelta: (value: string, options?: StorageOptions) => Promise<void>;
+  getLastUserSync: (options?: StorageOptions) => Promise<Date>;
+  setLastUserSync: (value: Date, options?: StorageOptions) => Promise<void>;
+  getLastGroupSync: (options?: StorageOptions) => Promise<Date>;
+  setLastGroupSync: (value: Date, options?: StorageOptions) => Promise<void>;
+  getGroupDelta: (options?: StorageOptions) => Promise<string>;
+  setGroupDelta: (value: string, options?: StorageOptions) => Promise<void>;
+  getLastSyncHash: (options?: StorageOptions) => Promise<string>;
+  setLastSyncHash: (value: string, options?: StorageOptions) => Promise<void>;
+  getSyncingDir: (options?: StorageOptions) => Promise<boolean>;
+  setSyncingDir: (value: boolean, options?: StorageOptions) => Promise<void>;
+  clearSyncSettings: (syncHashToo: boolean) => Promise<void>;
+}

src/app/accounts/apiKey.component.html

@@ -0,0 +1,60 @@
+<div class="container-fluid">
+  <form #form (ngSubmit)="submit()" [appApiAction]="formPromise">
+    <div class="row justify-content-center">
+      <div class="col-md-8 col-lg-6">
+        <p class="text-center font-weight-bold">{{ "welcome" | i18n }}</p>
+        <p class="text-center">{{ "logInDesc" | i18n }}</p>
+        <div class="card">
+          <h5 class="card-header">{{ "logIn" | i18n }}</h5>
+          <div class="card-body">
+            <div class="form-group">
+              <label for="client_id">{{ "clientId" | i18n }}</label>
+              <input id="client_id" name="ClientId" [(ngModel)]="clientId" class="form-control" />
+            </div>
+            <div class="form-group">
+              <div class="row-main">
+                <label for="client_secret">{{ "clientSecret" | i18n }}</label>
+                <div class="input-group">
+                  <input
+                    type="{{ showSecret ? 'text' : 'password' }}"
+                    id="client_secret"
+                    name="ClientSecret"
+                    [(ngModel)]="clientSecret"
+                    class="form-control"
+                  />
+                  <div class="input-group-append">
+                    <button
+                      type="button"
+                      class="ml-1 btn btn-link"
+                      appA11yTitle="{{ 'toggleVisibility' | i18n }}"
+                      (click)="toggleSecret()"
+                    >
+                      <i
+                        class="bwi bwi-lg"
+                        aria-hidden="true"
+                        [ngClass]="showSecret ? 'bwi-eye-slash' : 'bwi-eye'"
+                      ></i>
+                    </button>
+                  </div>
+                </div>
+              </div>
+            </div>
+            <div class="d-flex">
+              <div>
+                <button type="submit" class="btn btn-primary" [disabled]="form.loading">
+                  <i class="bwi bwi-spinner bwi-fw bwi-spin" [hidden]="!form.loading"></i>
+                  <i class="bwi bwi-sign-in bwi-fw" [hidden]="form.loading"></i>
+                  {{ "logIn" | i18n }}
+                </button>
+              </div>
+              <button type="button" class="btn btn-link ml-auto" (click)="settings()">
+                {{ "settings" | i18n }}
+              </button>
+            </div>
+          </div>
+        </div>
+      </div>
+    </div>
+  </form>
+</div>
+<ng-template #environment></ng-template>

src/app/accounts/apiKey.component.ts

@@ -0,0 +1,103 @@
+import { Component, Input, ViewChild, ViewContainerRef } from "@angular/core";
+import { Router } from "@angular/router";
+
+import { EnvironmentComponent } from "./environment.component";
+
+import { AuthService } from "jslib-common/abstractions/auth.service";
+import { I18nService } from "jslib-common/abstractions/i18n.service";
+import { LogService } from "jslib-common/abstractions/log.service";
+import { PlatformUtilsService } from "jslib-common/abstractions/platformUtils.service";
+
+import { StateService } from "../../abstractions/state.service";
+
+import { ModalService } from "jslib-angular/services/modal.service";
+
+import { HtmlStorageLocation } from "jslib-common/enums/htmlStorageLocation";
+import { Utils } from "jslib-common/misc/utils";
+
+@Component({
+  selector: "app-apiKey",
+  templateUrl: "apiKey.component.html",
+})
+export class ApiKeyComponent {
+  @ViewChild("environment", { read: ViewContainerRef, static: true })
+  environmentModal: ViewContainerRef;
+  @Input() clientId: string = "";
+  @Input() clientSecret: string = "";
+
+  formPromise: Promise<any>;
+  successRoute = "/tabs/dashboard";
+  showSecret: boolean = false;
+
+  constructor(
+    private authService: AuthService,
+    private router: Router,
+    private i18nService: I18nService,
+    private platformUtilsService: PlatformUtilsService,
+    private modalService: ModalService,
+    private logService: LogService,
+    private stateService: StateService
+  ) {}
+
+  async submit() {
+    if (this.clientId == null || this.clientId === "") {
+      this.platformUtilsService.showToast(
+        "error",
+        this.i18nService.t("errorOccurred"),
+        this.i18nService.t("clientIdRequired")
+      );
+      return;
+    }
+    if (!this.clientId.startsWith("organization")) {
+      this.platformUtilsService.showToast(
+        "error",
+        this.i18nService.t("errorOccurred"),
+        this.i18nService.t("orgApiKeyRequired")
+      );
+      return;
+    }
+    if (this.clientSecret == null || this.clientSecret === "") {
+      this.platformUtilsService.showToast(
+        "error",
+        this.i18nService.t("errorOccurred"),
+        this.i18nService.t("clientSecretRequired")
+      );
+      return;
+    }
+    const idParts = this.clientId.split(".");
+
+    if (idParts.length !== 2 || idParts[0] !== "organization" || !Utils.isGuid(idParts[1])) {
+      this.platformUtilsService.showToast(
+        "error",
+        this.i18nService.t("errorOccurred"),
+        this.i18nService.t("invalidClientId")
+      );
+      return;
+    }
+
+    try {
+      this.formPromise = this.authService.logInApiKey(this.clientId, this.clientSecret);
+      await this.formPromise;
+      const organizationId = await this.stateService.getEntityId();
+      await this.stateService.setOrganizationId(organizationId);
+      this.router.navigate([this.successRoute]);
+    } catch (e) {
+      this.logService.error(e);
+    }
+  }
+
+  async settings() {
+    const [modalRef, childComponent] = await this.modalService.openViewRef(
+      EnvironmentComponent,
+      this.environmentModal
+    );
+
+    childComponent.onSaved.subscribe(() => {
+      modalRef.close();
+    });
+  }
+  toggleSecret() {
+    this.showSecret = !this.showSecret;
+    document.getElementById("client_secret").focus();
+  }
+}

src/app/accounts/environment.component.html

@@ -1,43 +1,61 @@
 <div class="modal fade">
-    <div class="modal-dialog">
-        <form class="modal-content" (ngSubmit)="submit()">
-            <div class="modal-header">
-                <h3 class="modal-title">{{'settings' | i18n}}</h3>
-                <button type="button" class="close" data-dismiss="modal" title="Close">
-                    <span aria-hidden="true">&times;</span>
-                </button>
-            </div>
-            <div class="modal-body">
-                <h4>{{'selfHostedEnvironment' | i18n}}</h4>
-                <p>{{'selfHostedEnvironmentFooter' | i18n}}</p>
-                <div class="form-group">
-                    <label for="baseUrl">{{'baseUrl' | i18n}}</label>
-                    <input id="baseUrl" type="text" name="BaseUrl" [(ngModel)]="baseUrl" class="form-control">
-                    <small class="text-muted form-text">{{'ex' | i18n}} https://bitwarden.company.com</small>
-                </div>
-                <h4>{{'customEnvironment' | i18n}}</h4>
-                <p>{{'customEnvironmentFooter' | i18n}}</p>
-                <div class="form-group">
-                    <label for="webVaultUrl">{{'webVaultUrl' | i18n}}</label>
-                    <input id="webVaultUrl" type="text" name="WebVaultUrl" [(ngModel)]="webVaultUrl"
-                        class="form-control">
-                </div>
-                <div class="form-group">
-                    <label for="apiUrl">{{'apiUrl' | i18n}}</label>
-                    <input id="apiUrl" type="text" name="ApiUrl" [(ngModel)]="apiUrl" class="form-control">
-                </div>
-                <div class="form-group">
-                    <label for="identityUrl">{{'identityUrl' | i18n}}</label>
-                    <input id="identityUrl" type="text" name="IdentityUrl" [(ngModel)]="identityUrl"
-                        class="form-control">
-                </div>
-            </div>
-            <div class="modal-footer justify-content-start">
-                <button type="submit" class="btn btn-primary">
-                    <i class="fa fa-save fa-fw"></i>
-                    {{'save' | i18n}}
-                </button>
-            </div>
-        </form>
-    </div>
+  <div class="modal-dialog">
+    <form class="modal-content" (ngSubmit)="submit()">
+      <div class="modal-header">
+        <h3 class="modal-title">{{ "settings" | i18n }}</h3>
+        <button type="button" class="close" data-dismiss="modal" title="Close">
+          <span aria-hidden="true">&times;</span>
+        </button>
+      </div>
+      <div class="modal-body">
+        <h4>{{ "selfHostedEnvironment" | i18n }}</h4>
+        <p>{{ "selfHostedEnvironmentFooter" | i18n }}</p>
+        <div class="form-group">
+          <label for="baseUrl">{{ "baseUrl" | i18n }}</label>
+          <input
+            id="baseUrl"
+            type="text"
+            name="BaseUrl"
+            [(ngModel)]="baseUrl"
+            class="form-control"
+          />
+          <small class="text-muted form-text"
+            >{{ "ex" | i18n }} https://bitwarden.company.com</small
+          >
+        </div>
+        <h4>{{ "customEnvironment" | i18n }}</h4>
+        <p>{{ "customEnvironmentFooter" | i18n }}</p>
+        <div class="form-group">
+          <label for="webVaultUrl">{{ "webVaultUrl" | i18n }}</label>
+          <input
+            id="webVaultUrl"
+            type="text"
+            name="WebVaultUrl"
+            [(ngModel)]="webVaultUrl"
+            class="form-control"
+          />
+        </div>
+        <div class="form-group">
+          <label for="apiUrl">{{ "apiUrl" | i18n }}</label>
+          <input id="apiUrl" type="text" name="ApiUrl" [(ngModel)]="apiUrl" class="form-control" />
+        </div>
+        <div class="form-group">
+          <label for="identityUrl">{{ "identityUrl" | i18n }}</label>
+          <input
+            id="identityUrl"
+            type="text"
+            name="IdentityUrl"
+            [(ngModel)]="identityUrl"
+            class="form-control"
+          />
+        </div>
+      </div>
+      <div class="modal-footer justify-content-start">
+        <button type="submit" class="btn btn-primary">
+          <i class="bwi bwi-save bwi-fw"></i>
+          {{ "save" | i18n }}
+        </button>
+      </div>
+    </form>
+  </div>
 </div>

src/app/accounts/environment.component.ts

@@ -1,18 +1,21 @@
-import { Component } from '@angular/core';
+import { Component } from "@angular/core";
 
-import { EnvironmentService } from 'jslib/abstractions/environment.service';
-import { I18nService } from 'jslib/abstractions/i18n.service';
-import { PlatformUtilsService } from 'jslib/abstractions/platformUtils.service';
+import { EnvironmentService } from "jslib-common/abstractions/environment.service";
+import { I18nService } from "jslib-common/abstractions/i18n.service";
+import { PlatformUtilsService } from "jslib-common/abstractions/platformUtils.service";
 
-import { EnvironmentComponent as BaseEnvironmentComponent } from 'jslib/angular/components/environment.component';
+import { EnvironmentComponent as BaseEnvironmentComponent } from "jslib-angular/components/environment.component";
 
 @Component({
-    selector: 'app-environment',
-    templateUrl: 'environment.component.html',
+  selector: "app-environment",
+  templateUrl: "environment.component.html",
 })
 export class EnvironmentComponent extends BaseEnvironmentComponent {
-    constructor(environmentService: EnvironmentService, i18nService: I18nService,
-        platformUtilsService: PlatformUtilsService) {
-        super(platformUtilsService, environmentService, i18nService);
-    }
+  constructor(
+    environmentService: EnvironmentService,
+    i18nService: I18nService,
+    platformUtilsService: PlatformUtilsService
+  ) {
+    super(platformUtilsService, environmentService, i18nService);
+  }
 }

src/app/accounts/login.component.html

@@ -1,43 +0,0 @@
-<div class="container-fluid">
-    <form #form (ngSubmit)="submit()" [appApiAction]="formPromise">
-        <div class="row justify-content-center">
-            <div class="col-md-8 col-lg-6">
-                <p class="text-center font-weight-bold">{{'welcome' | i18n}}</p>
-                <p class="text-center">{{'logInDesc' | i18n}}</p>
-                <div class="card">
-                    <h5 class="card-header">{{'logIn' | i18n}}</h5>
-                    <div class="card-body">
-                        <div class="form-group">
-                            <label for="email">{{'emailAddress' | i18n}}</label>
-                            <input id="email" type="text" name="Email" [(ngModel)]="email" class="form-control">
-                        </div>
-                        <div class="form-group">
-                            <div class="row-main">
-                                <label for="masterPassword">{{'masterPass' | i18n}}</label>
-                                <input id="masterPassword" type="password" name="MasterPassword"
-                                    [(ngModel)]="masterPassword" class="form-control">
-                            </div>
-                        </div>
-                        <div class="d-flex">
-                            <div>
-                                <button type="submit" class="btn btn-primary" [disabled]="form.loading">
-                                    <i class="fa fa-spinner fa-fw fa-spin" [hidden]="!form.loading"></i>
-                                    <i class="fa fa-sign-in fa-fw" [hidden]="form.loading"></i>
-                                    {{'logIn' | i18n}}
-                                </button>
-                                <button type="button" class="btn btn-secondary ml-1" (click)="sso()">
-                                    <i class="fa fa-bank" aria-hidden="true"></i>
-                                    {{'enterpriseSingleSignOn' | i18n}}
-                                </button>
-                            </div>
-                            <button type="button" class="btn btn-link ml-auto" (click)="settings()">
-                                {{'settings' | i18n}}
-                            </button>
-                        </div>
-                    </div>
-                </div>
-            </div>
-        </div>
-    </form>
-</div>
-<ng-template #environment></ng-template>

src/app/accounts/login.component.ts

@@ -1,57 +0,0 @@
-import {
-    Component,
-    ComponentFactoryResolver,
-    ViewChild,
-    ViewContainerRef,
-} from '@angular/core';
-import { Router } from '@angular/router';
-
-import { EnvironmentComponent } from './environment.component';
-
-import { AuthService } from 'jslib/abstractions/auth.service';
-import { CryptoFunctionService } from 'jslib/abstractions/cryptoFunction.service';
-import { EnvironmentService } from 'jslib/abstractions/environment.service';
-import { I18nService } from 'jslib/abstractions/i18n.service';
-import { PasswordGenerationService } from 'jslib/abstractions/passwordGeneration.service';
-import { PlatformUtilsService } from 'jslib/abstractions/platformUtils.service';
-import { StateService } from 'jslib/abstractions/state.service';
-import { StorageService } from 'jslib/abstractions/storage.service';
-
-import { LoginComponent as BaseLoginComponent } from 'jslib/angular/components/login.component';
-import { ModalComponent } from 'jslib/angular/components/modal.component';
-
-@Component({
-    selector: 'app-login',
-    templateUrl: 'login.component.html',
-})
-export class LoginComponent extends BaseLoginComponent {
-    @ViewChild('environment', { read: ViewContainerRef, static: true }) environmentModal: ViewContainerRef;
-
-    constructor(authService: AuthService, router: Router,
-        i18nService: I18nService, private componentFactoryResolver: ComponentFactoryResolver,
-        storageService: StorageService, stateService: StateService,
-        platformUtilsService: PlatformUtilsService, environmentService: EnvironmentService,
-        passwordGenerationService: PasswordGenerationService, cryptoFunctionService: CryptoFunctionService) {
-        super(authService, router,
-            platformUtilsService, i18nService,
-            stateService, environmentService,
-            passwordGenerationService, cryptoFunctionService,
-            storageService);
-        super.successRoute = '/tabs/dashboard';
-    }
-
-    settings() {
-        const factory = this.componentFactoryResolver.resolveComponentFactory(ModalComponent);
-        const modal = this.environmentModal.createComponent(factory).instance;
-        const childComponent = modal.show<EnvironmentComponent>(EnvironmentComponent,
-            this.environmentModal);
-
-        childComponent.onSaved.subscribe(() => {
-            modal.close();
-        });
-    }
-
-    sso() {
-        return super.launchSsoBrowser('connector', 'bwdc://sso-callback');
-    }
-}

src/app/accounts/sso.component.html

@@ -1,30 +0,0 @@
-<div class="container-fluid">
-    <form #form (ngSubmit)="submit()" [appApiAction]="formPromise">
-        <div class="row justify-content-center">
-            <div class="col-md-8 col-lg-6">
-                <div class="card" *ngIf="!showMasterPassRedirect">
-                    <div class="card-body">
-                        <i class="fa fa-spinner fa-spin" title="{{'loading' | i18n}}" aria-hidden="true"></i>
-                        {{'loading' | i18n}}
-                    </div>
-                </div>
-                <div class="card" *ngIf="showMasterPassRedirect">
-                    <h5 class="card-header">{{'setMasterPassword' | i18n}}</h5>
-                    <div class="card-body">
-                        <p class="text-center">{{'setMasterPasswordRedirect' | i18n}}</p>
-                        <hr>
-                        <div class="d-flex">
-                            <button type="button" class="btn btn-primary btn-block btn-submit"
-                                (click)="launchWebVault()">
-                                {{'launchWebVault' | i18n}}
-                            </button>
-                            <button type="button" class="btn btn-secondary btn-block ml-2 mt-0" (click)="logOut()">
-                                {{'logOut' | i18n}}
-                            </button>
-                        </div>
-                    </div>
-                </div>
-            </div>
-        </div>
-    </form>
-</div>

src/app/accounts/sso.component.ts

@@ -1,61 +0,0 @@
-import { Component } from '@angular/core';
-
-import {
-    ActivatedRoute,
-    Router,
-} from '@angular/router';
-
-import { ApiService } from 'jslib/abstractions/api.service';
-import { AuthService } from 'jslib/abstractions/auth.service';
-import { CryptoFunctionService } from 'jslib/abstractions/cryptoFunction.service';
-import { EnvironmentService } from 'jslib/abstractions/environment.service';
-import { I18nService } from 'jslib/abstractions/i18n.service';
-import { MessagingService } from 'jslib/abstractions/messaging.service';
-import { PasswordGenerationService } from 'jslib/abstractions/passwordGeneration.service';
-import { PlatformUtilsService } from 'jslib/abstractions/platformUtils.service';
-import { StateService } from 'jslib/abstractions/state.service';
-import { StorageService } from 'jslib/abstractions/storage.service';
-
-import { SsoComponent as BaseSsoComponent } from 'jslib/angular/components/sso.component';
-
-@Component({
-    selector: 'app-sso',
-    templateUrl: 'sso.component.html',
-})
-export class SsoComponent extends BaseSsoComponent {
-    showMasterPassRedirect: boolean = false;
-
-    constructor(authService: AuthService, router: Router,
-        i18nService: I18nService, route: ActivatedRoute,
-        storageService: StorageService, stateService: StateService,
-        platformUtilsService: PlatformUtilsService, apiService: ApiService,
-        cryptoFunctionService: CryptoFunctionService,
-        passwordGenerationService: PasswordGenerationService, private messagingService: MessagingService,
-        private environmentService: EnvironmentService) {
-        super(authService, router, i18nService, route, storageService, stateService, platformUtilsService,
-            apiService, cryptoFunctionService, passwordGenerationService);
-        this.successRoute = '/tabs/dashboard';
-        this.redirectUri = 'bwdc://sso-callback';
-        this.clientId = 'connector';
-        this.onSuccessfulLoginChangePasswordNavigate = this.redirectSetMasterPass;
-    }
-
-    async redirectSetMasterPass() {
-        this.showMasterPassRedirect = true;
-    }
-
-    launchWebVault() {
-        const webUrl = this.environmentService.webVaultUrl == null ? 'https://vault.bitwarden.com' :
-            this.environmentService.webVaultUrl;
-
-        this.platformUtilsService.launchUri(webUrl);
-    }
-
-    async logOut() {
-        const confirmed = await this.platformUtilsService.showDialog(this.i18nService.t('logOutConfirmation'),
-            this.i18nService.t('logOut'), this.i18nService.t('logOut'), this.i18nService.t('cancel'));
-        if (confirmed) {
-            this.messagingService.send('logout');
-        }
-    }
-}

src/app/accounts/two-factor-options.component.html

@@ -1,26 +0,0 @@
-<div class="modal fade">
-    <div class="modal-dialog">
-        <div class="modal-content">
-            <div class="modal-header">
-                <h3 class="modal-title">{{'twoStepOptions' | i18n}}</h3>
-                <button type="button" class="close" data-dismiss="modal" title="Close">
-                    <span aria-hidden="true">&times;</span>
-                </button>
-            </div>
-            <div class="modal-body">
-                <p *ngFor="let p of providers">
-                    <a href="#" appStopClick (click)="choose(p)">
-                        <strong>{{p.name}}</strong>
-                    </a>
-                    <br /> {{p.description}}
-                </p>
-                <p>
-                    <a href="#" (click)="recover()">
-                        <strong>{{'recoveryCodeTitle' | i18n}}</strong>
-                    </a>
-                    <br /> {{'recoveryCodeDesc' | i18n}}
-                </p>
-            </div>
-        </div>
-    </div>
-</div>

src/app/accounts/two-factor-options.component.ts

@@ -1,21 +0,0 @@
-import { Component } from '@angular/core';
-import { Router } from '@angular/router';
-
-import { AuthService } from 'jslib/abstractions/auth.service';
-import { I18nService } from 'jslib/abstractions/i18n.service';
-import { PlatformUtilsService } from 'jslib/abstractions/platformUtils.service';
-
-import {
-    TwoFactorOptionsComponent as BaseTwoFactorOptionsComponent,
-} from 'jslib/angular/components/two-factor-options.component';
-
-@Component({
-    selector: 'app-two-factor-options',
-    templateUrl: 'two-factor-options.component.html',
-})
-export class TwoFactorOptionsComponent extends BaseTwoFactorOptionsComponent {
-    constructor(authService: AuthService, router: Router,
-        i18nService: I18nService, platformUtilsService: PlatformUtilsService) {
-        super(authService, router, i18nService, platformUtilsService, window);
-    }
-}

src/app/accounts/two-factor.component.html

@@ -1,70 +0,0 @@
-<div class="container-fluid">
-    <form #form (ngSubmit)="submit()" [appApiAction]="formPromise">
-        <div class="row justify-content-center">
-            <div class="col-md-8 col-lg-6">
-                <div class="card">
-                    <h5 class="card-header">{{title}}</h5>
-                    <div class="card-body">
-                        <ng-container
-                            *ngIf="selectedProviderType === providerType.Email || selectedProviderType === providerType.Authenticator">
-                            <p *ngIf="selectedProviderType === providerType.Authenticator">
-                                {{'enterVerificationCodeApp' | i18n}}
-                            </p>
-                            <p *ngIf="selectedProviderType === providerType.Email">
-                                {{'enterVerificationCodeEmail' | i18n : twoFactorEmail}}
-                            </p>
-                            <div class="form-group">
-                                <label for="code">{{'verificationCode' | i18n}}</label>
-                                <input id="code" type="text" name="Code" [(ngModel)]="token" appAutofocus
-                                    class="form-control">
-                            </div>
-                        </ng-container>
-                        <ng-container *ngIf="selectedProviderType === providerType.Yubikey">
-                            <p>{{'insertYubiKey' | i18n}}</p>
-                            <p><img src="../../images/yubikey.jpg" class="img-fluid rounded" alt=""></p>
-                            <div class="form-group">
-                                <label for="code">{{'verificationCode' | i18n}}</label>
-                                <input id="code" type="password" name="Code" [(ngModel)]="token" appAutofocus
-                                    class="form-control">
-                            </div>
-                        </ng-container>
-                        <ng-container *ngIf="selectedProviderType === providerType.Duo ||
-                                              selectedProviderType === providerType.OrganizationDuo">
-                            <div id="duo-frame">
-                                <iframe id="duo_iframe"></iframe>
-                            </div>
-                        </ng-container>
-                        <div class="form-group"
-                            *ngIf="selectedProviderType != null && selectedProviderType !== providerType.U2f">
-                            <div class="form-check">
-                                <input class="form-check-input" type="checkbox" id="remember" [(ngModel)]="remember"
-                                    name="Remember">
-                                <label class="form-check-label" for="remember">{{'rememberMe' | i18n}}</label>
-                            </div>
-                        </div>
-                        <ng-container class="card-body"
-                            *ngIf="selectedProviderType === null || selectedProviderType === providerType.U2f">
-                            <p>{{'noTwoStepProviders' | i18n}}</p>
-                            <p>{{'noTwoStepProviders2' | i18n}}</p>
-                        </ng-container>
-                        <button type="submit" class="btn btn-primary" [disabled]="form.loading" *ngIf="selectedProviderType != null && selectedProviderType !== providerType.U2f && selectedProviderType !== providerType.Duo && 
-                        selectedProviderType !== providerType.OrganizationDuo">
-                            <i class="fa fa-sign-in fa-fw" [hidden]="form.loading"></i>
-                            <i class="fa fa-spinner fa-fw fa-spin" [hidden]="!form.loading"></i>
-                            {{'continue' | i18n}}
-                        </button>
-                        <a routerLink="/login" class="btn btn-link">{{'cancel' | i18n}}</a>
-                    </div>
-                </div>
-                <div class="text-center mt-3">
-                    <a href="#" appStopClick (click)="anotherMethod()">{{'useAnotherTwoStepMethod' | i18n}}</a>
-                    <a href="#" appStopClick (click)="sendEmail(true)" [appApiAction]="emailPromise"
-                        *ngIf="selectedProviderType === providerType.Email">
-                        {{'sendVerificationCodeEmailAgain' | i18n}}
-                    </a>
-                </div>
-            </div>
-        </div>
-    </form>
-</div>
-<ng-template #twoFactorOptions></ng-template>

src/app/accounts/two-factor.component.ts

@@ -1,64 +0,0 @@
-import {
-    Component,
-    ComponentFactoryResolver,
-    ViewChild,
-    ViewContainerRef,
-} from '@angular/core';
-
-import {
-    ActivatedRoute,
-    Router,
-} from '@angular/router';
-
-import { TwoFactorOptionsComponent } from './two-factor-options.component';
-
-import { TwoFactorProviderType } from 'jslib/enums/twoFactorProviderType';
-
-import { ApiService } from 'jslib/abstractions/api.service';
-import { AuthService } from 'jslib/abstractions/auth.service';
-import { EnvironmentService } from 'jslib/abstractions/environment.service';
-import { I18nService } from 'jslib/abstractions/i18n.service';
-import { PlatformUtilsService } from 'jslib/abstractions/platformUtils.service';
-import { StateService } from 'jslib/abstractions/state.service';
-import { StorageService } from 'jslib/abstractions/storage.service';
-
-import { ModalComponent } from 'jslib/angular/components/modal.component';
-import { TwoFactorComponent as BaseTwoFactorComponent } from 'jslib/angular/components/two-factor.component';
-
-@Component({
-    selector: 'app-two-factor',
-    templateUrl: 'two-factor.component.html',
-})
-export class TwoFactorComponent extends BaseTwoFactorComponent {
-    @ViewChild('twoFactorOptions', { read: ViewContainerRef, static: true }) twoFactorOptionsModal: ViewContainerRef;
-
-    constructor(authService: AuthService, router: Router,
-        i18nService: I18nService, apiService: ApiService,
-        platformUtilsService: PlatformUtilsService, environmentService: EnvironmentService,
-        private componentFactoryResolver: ComponentFactoryResolver, stateService: StateService,
-        storageService: StorageService, route: ActivatedRoute) {
-        super(authService, router, i18nService, apiService, platformUtilsService, window, environmentService,
-            stateService, storageService, route);
-    }
-
-    async ngOnInit() {
-        await super.ngOnInit();
-        super.successRoute = '/tabs/dashboard';
-    }
-
-    anotherMethod() {
-        const factory = this.componentFactoryResolver.resolveComponentFactory(ModalComponent);
-        const modal = this.twoFactorOptionsModal.createComponent(factory).instance;
-        const childComponent = modal.show<TwoFactorOptionsComponent>(TwoFactorOptionsComponent,
-            this.twoFactorOptionsModal);
-
-        childComponent.onProviderSelected.subscribe(async (provider: TwoFactorProviderType) => {
-            modal.close();
-            this.selectedProviderType = provider;
-            await this.init();
-        });
-        childComponent.onRecoverSelected.subscribe(() => {
-            modal.close();
-        });
-    }
-}

src/app/app-routing.module.ts

@@ -1,62 +1,57 @@
-import { NgModule } from '@angular/core';
-import {
-    RouterModule,
-    Routes,
-} from '@angular/router';
+import { NgModule } from "@angular/core";
+import { RouterModule, Routes } from "@angular/router";
 
-import { AuthGuardService } from './services/auth-guard.service';
-import { LaunchGuardService } from './services/launch-guard.service';
+import { AuthGuardService } from "./services/auth-guard.service";
+import { LaunchGuardService } from "./services/launch-guard.service";
 
-import { LoginComponent } from './accounts/login.component';
-import { SsoComponent } from './accounts/sso.component';
-import { TwoFactorComponent } from './accounts/two-factor.component';
-import { DashboardComponent } from './tabs/dashboard.component';
-import { MoreComponent } from './tabs/more.component';
-import { SettingsComponent } from './tabs/settings.component';
-import { TabsComponent } from './tabs/tabs.component';
+import { ApiKeyComponent } from "./accounts/apiKey.component";
+import { DashboardComponent } from "./tabs/dashboard.component";
+import { MoreComponent } from "./tabs/more.component";
+import { SettingsComponent } from "./tabs/settings.component";
+import { TabsComponent } from "./tabs/tabs.component";
 
 const routes: Routes = [
-    { path: '', redirectTo: '/login', pathMatch: 'full' },
-    {
-        path: 'login',
-        component: LoginComponent,
-        canActivate: [LaunchGuardService],
-    },
-    { path: '2fa', component: TwoFactorComponent },
-    { path: 'sso', component: SsoComponent },
-    {
-        path: 'tabs',
-        component: TabsComponent,
-        children: [
-            {
-                path: '',
-                redirectTo: '/tabs/dashboard',
-                pathMatch: 'full',
-            },
-            {
-                path: 'dashboard',
-                component: DashboardComponent,
-                canActivate: [AuthGuardService],
-            },
-            {
-                path: 'settings',
-                component: SettingsComponent,
-                canActivate: [AuthGuardService],
-            },
-            {
-                path: 'more',
-                component: MoreComponent,
-                canActivate: [AuthGuardService],
-            },
-        ],
-    },
+  { path: "", redirectTo: "/login", pathMatch: "full" },
+  {
+    path: "login",
+    component: ApiKeyComponent,
+    canActivate: [LaunchGuardService],
+  },
+  {
+    path: "tabs",
+    component: TabsComponent,
+    children: [
+      {
+        path: "",
+        redirectTo: "/tabs/dashboard",
+        pathMatch: "full",
+      },
+      {
+        path: "dashboard",
+        component: DashboardComponent,
+        canActivate: [AuthGuardService],
+      },
+      {
+        path: "settings",
+        component: SettingsComponent,
+        canActivate: [AuthGuardService],
+      },
+      {
+        path: "more",
+        component: MoreComponent,
+        canActivate: [AuthGuardService],
+      },
+    ],
+  },
 ];
 
 @NgModule({
-    imports: [RouterModule.forRoot(routes, {
-        useHash: true,
-        /*enableTracing: true,*/
-    })],
-    exports: [RouterModule],
+  imports: [
+    RouterModule.forRoot(routes, {
+      useHash: true,
+      /*enableTracing: true,*/
+    }),
+  ],
+  exports: [RouterModule],
 })
-export class AppRoutingModule { }
+export class AppRoutingModule {}

src/app/app.component.ts

@@ -1,197 +1,161 @@
 import {
-    BodyOutputType,
-    Toast,
-    ToasterConfig,
-    ToasterContainerComponent,
-    ToasterService,
-} from 'angular2-toaster';
+  Component,
+  NgZone,
+  OnInit,
+  SecurityContext,
+  ViewChild,
+  ViewContainerRef,
+} from "@angular/core";
+import { DomSanitizer } from "@angular/platform-browser";
+import { Router } from "@angular/router";
+import { IndividualConfig, ToastrService } from "ngx-toastr";
 
-import {
-    Component,
-    ComponentFactoryResolver,
-    NgZone,
-    OnInit,
-    SecurityContext,
-    Type,
-    ViewChild,
-    ViewContainerRef,
-} from '@angular/core';
-import { DomSanitizer } from '@angular/platform-browser';
-import { Router } from '@angular/router';
+import { AuthService } from "jslib-common/abstractions/auth.service";
+import { BroadcasterService } from "jslib-common/abstractions/broadcaster.service";
+import { I18nService } from "jslib-common/abstractions/i18n.service";
+import { LogService } from "jslib-common/abstractions/log.service";
+import { MessagingService } from "jslib-common/abstractions/messaging.service";
+import { PlatformUtilsService } from "jslib-common/abstractions/platformUtils.service";
+import { TokenService } from "jslib-common/abstractions/token.service";
 
-import { ModalComponent } from 'jslib/angular/components/modal.component';
+import { SyncService } from "../services/sync.service";
 
-import { BroadcasterService } from 'jslib/angular/services/broadcaster.service';
+import { StateService } from "../abstractions/state.service";
 
-import { ApiService } from 'jslib/abstractions/api.service';
-import { AuthService } from 'jslib/abstractions/auth.service';
-import { I18nService } from 'jslib/abstractions/i18n.service';
-import { MessagingService } from 'jslib/abstractions/messaging.service';
-import { StateService } from 'jslib/abstractions/state.service';
-import { StorageService } from 'jslib/abstractions/storage.service';
-import { TokenService } from 'jslib/abstractions/token.service';
-import { UserService } from 'jslib/abstractions/user.service';
-
-import { ConfigurationService } from '../services/configuration.service';
-import { SyncService } from '../services/sync.service';
-
-const BroadcasterSubscriptionId = 'AppComponent';
+const BroadcasterSubscriptionId = "AppComponent";
 
 @Component({
-    selector: 'app-root',
-    styles: [],
-    template: `
-        <toaster-container [toasterconfig]="toasterConfig"></toaster-container>
-        <ng-template #settings></ng-template>
-        <router-outlet></router-outlet>`,
+  selector: "app-root",
+  styles: [],
+  template: ` <ng-template #settings></ng-template>
+    <router-outlet></router-outlet>`,
 })
 export class AppComponent implements OnInit {
-    @ViewChild('settings', { read: ViewContainerRef, static: true }) settingsRef: ViewContainerRef;
+  @ViewChild("settings", { read: ViewContainerRef, static: true }) settingsRef: ViewContainerRef;
 
-    toasterConfig: ToasterConfig = new ToasterConfig({
-        showCloseButton: true,
-        mouseoverTimerStop: true,
-        animation: 'flyRight',
-        limit: 5,
-    });
+  constructor(
+    private broadcasterService: BroadcasterService,
+    private tokenService: TokenService,
+    private authService: AuthService,
+    private router: Router,
+    private toastrService: ToastrService,
+    private i18nService: I18nService,
+    private sanitizer: DomSanitizer,
+    private ngZone: NgZone,
+    private platformUtilsService: PlatformUtilsService,
+    private messagingService: MessagingService,
+    private syncService: SyncService,
+    private stateService: StateService,
+    private logService: LogService
+  ) {}
 
-    private lastActivity: number = null;
-    private modal: ModalComponent = null;
+  ngOnInit() {
+    this.broadcasterService.subscribe(BroadcasterSubscriptionId, async (message: any) => {
+      this.ngZone.run(async () => {
+        switch (message.command) {
+          case "syncScheduleStarted":
+          case "syncScheduleStopped":
+            this.stateService.setSyncingDir(message.command === "syncScheduleStarted");
+            break;
+          case "logout":
+            this.logOut(!!message.expired);
+            break;
+          case "checkDirSync":
+            try {
+              const syncConfig = await this.stateService.getSync();
+              if (syncConfig.interval == null || syncConfig.interval < 5) {
+                return;
+              }
 
-    constructor(private broadcasterService: BroadcasterService, private userService: UserService,
-        private tokenService: TokenService, private storageService: StorageService,
-        private authService: AuthService, private router: Router,
-        private toasterService: ToasterService, private i18nService: I18nService,
-        private sanitizer: DomSanitizer, private ngZone: NgZone,
-        private componentFactoryResolver: ComponentFactoryResolver, private messagingService: MessagingService,
-        private configurationService: ConfigurationService, private syncService: SyncService,
-        private stateService: StateService, private apiService: ApiService) {
-        (window as any).BitwardenToasterService = toasterService;
-    }
-
-    ngOnInit() {
-        this.broadcasterService.subscribe(BroadcasterSubscriptionId, async (message: any) => {
-            this.ngZone.run(async () => {
-                switch (message.command) {
-                    case 'loggedIn':
-                        if (await this.userService.isAuthenticated()) {
-                            const profile = await this.apiService.getProfile();
-                            this.stateService.save('profileOrganizations', profile.organizations);
-                        }
-                        break;
-                    case 'syncScheduleStarted':
-                    case 'syncScheduleStopped':
-                        this.stateService.save('syncingDir', message.command === 'syncScheduleStarted');
-                        break;
-                    case 'logout':
-                        this.logOut(!!message.expired);
-                        break;
-                    case 'checkDirSync':
-                        try {
-                            const syncConfig = await this.configurationService.getSync();
-                            if (syncConfig.interval == null || syncConfig.interval < 5) {
-                                return;
-                            }
-
-                            const syncInterval = syncConfig.interval * 60000;
-                            const lastGroupSync = await this.configurationService.getLastGroupSyncDate();
-                            const lastUserSync = await this.configurationService.getLastUserSyncDate();
-                            let lastSync: Date = null;
-                            if (lastGroupSync != null && lastUserSync == null) {
-                                lastSync = lastGroupSync;
-                            } else if (lastGroupSync == null && lastUserSync != null) {
-                                lastSync = lastUserSync;
-                            } else if (lastGroupSync != null && lastUserSync != null) {
-                                if (lastGroupSync.getTime() < lastUserSync.getTime()) {
-                                    lastSync = lastGroupSync;
-                                } else {
-                                    lastSync = lastUserSync;
-                                }
-                            }
-
-                            let lastSyncAgo = syncInterval + 1;
-                            if (lastSync != null) {
-                                lastSyncAgo = new Date().getTime() - lastSync.getTime();
-                            }
-
-                            if (lastSyncAgo >= syncInterval) {
-                                await this.syncService.sync(false, false);
-                            }
-                        } catch { }
-
-                        this.messagingService.send('scheduleNextDirSync');
-                        break;
-                    case 'showToast':
-                        this.showToast(message);
-                        break;
-                    case 'ssoCallback':
-                        this.router.navigate(['sso'], { queryParams: { code: message.code, state: message.state } });
-                        break;
-                    default:
+              const syncInterval = syncConfig.interval * 60000;
+              const lastGroupSync = await this.stateService.getLastGroupSync();
+              const lastUserSync = await this.stateService.getLastUserSync();
+              let lastSync: Date = null;
+              if (lastGroupSync != null && lastUserSync == null) {
+                lastSync = lastGroupSync;
+              } else if (lastGroupSync == null && lastUserSync != null) {
+                lastSync = lastUserSync;
+              } else if (lastGroupSync != null && lastUserSync != null) {
+                if (lastGroupSync.getTime() < lastUserSync.getTime()) {
+                  lastSync = lastGroupSync;
+                } else {
+                  lastSync = lastUserSync;
                 }
+              }
+
+              let lastSyncAgo = syncInterval + 1;
+              if (lastSync != null) {
+                lastSyncAgo = new Date().getTime() - lastSync.getTime();
+              }
+
+              if (lastSyncAgo >= syncInterval) {
+                await this.syncService.sync(false, false);
+              }
+            } catch (e) {
+              this.logService.error(e);
+            }
+
+            this.messagingService.send("scheduleNextDirSync");
+            break;
+          case "showToast":
+            this.showToast(message);
+            break;
+          case "ssoCallback":
+            this.router.navigate(["sso"], {
+              queryParams: { code: message.code, state: message.state },
             });
-        });
-    }
-
-    ngOnDestroy() {
-        this.broadcasterService.unsubscribe(BroadcasterSubscriptionId);
-    }
-
-    private async logOut(expired: boolean) {
-        const userId = await this.userService.getUserId();
-
-        await Promise.all([
-            this.tokenService.clearToken(),
-            this.userService.clear(),
-        ]);
-
-        this.authService.logOut(async () => {
-            if (expired) {
-                this.toasterService.popAsync('warning', this.i18nService.t('loggedOut'),
-                    this.i18nService.t('loginExpired'));
-            }
-            this.router.navigate(['login']);
-        });
-    }
-
-    private openModal<T>(type: Type<T>, ref: ViewContainerRef) {
-        if (this.modal != null) {
-            this.modal.close();
+            break;
+          default:
         }
+      });
+    });
+  }
 
-        const factory = this.componentFactoryResolver.resolveComponentFactory(ModalComponent);
-        this.modal = ref.createComponent(factory).instance;
-        const childComponent = this.modal.show<T>(type, ref);
+  ngOnDestroy() {
+    this.broadcasterService.unsubscribe(BroadcasterSubscriptionId);
+  }
 
-        this.modal.onClosed.subscribe(() => {
-            this.modal = null;
-        });
+  private async logOut(expired: boolean) {
+    await this.tokenService.clearToken();
+    await this.stateService.clean();
+
+    this.authService.logOut(async () => {
+      if (expired) {
+        this.platformUtilsService.showToast(
+          "warning",
+          this.i18nService.t("loggedOut"),
+          this.i18nService.t("loginExpired")
+        );
+      }
+      this.router.navigate(["login"]);
+    });
+  }
+
+  private showToast(msg: any) {
+    let message = "";
+
+    const options: Partial<IndividualConfig> = {};
+
+    if (typeof msg.text === "string") {
+      message = msg.text;
+    } else if (msg.text.length === 1) {
+      message = msg.text[0];
+    } else {
+      msg.text.forEach(
+        (t: string) =>
+          (message += "<p>" + this.sanitizer.sanitize(SecurityContext.HTML, t) + "</p>")
+      );
+      options.enableHtml = true;
+    }
+    if (msg.options != null) {
+      if (msg.options.trustedHtml === true) {
+        options.enableHtml = true;
+      }
+      if (msg.options.timeout != null && msg.options.timeout > 0) {
+        options.timeOut = msg.options.timeout;
+      }
     }
 
-    private showToast(msg: any) {
-        const toast: Toast = {
-            type: msg.type,
-            title: msg.title,
-        };
-        if (typeof (msg.text) === 'string') {
-            toast.body = msg.text;
-        } else if (msg.text.length === 1) {
-            toast.body = msg.text[0];
-        } else {
-            let message = '';
-            msg.text.forEach((t: string) =>
-                message += ('<p>' + this.sanitizer.sanitize(SecurityContext.HTML, t) + '</p>'));
-            toast.body = message;
-            toast.bodyOutputType = BodyOutputType.TrustedHtml;
-        }
-        if (msg.options != null) {
-            if (msg.options.trustedHtml === true) {
-                toast.bodyOutputType = BodyOutputType.TrustedHtml;
-            }
-            if (msg.options.timeout != null && msg.options.timeout > 0) {
-                toast.timeout = msg.options.timeout;
-            }
-        }
-        this.toasterService.popAsync(toast);
-    }
+    this.toastrService.show(message, msg.title, options, "toast-" + msg.type);
+  }
 }

src/app/app.module.ts

@@ -1,84 +1,74 @@
-import 'core-js';
-import 'zone.js/dist/zone';
+import "core-js/stable";
+import "zone.js/dist/zone";
 
-import { ToasterModule } from 'angular2-toaster';
+import { AppRoutingModule } from "./app-routing.module";
+import { ServicesModule } from "./services/services.module";
 
-import { AppRoutingModule } from './app-routing.module';
-import { ServicesModule } from './services/services.module';
+import { NgModule } from "@angular/core";
+import { FormsModule } from "@angular/forms";
+import { BrowserModule } from "@angular/platform-browser";
+import { BrowserAnimationsModule } from "@angular/platform-browser/animations";
 
-import { NgModule } from '@angular/core';
-import { FormsModule } from '@angular/forms';
-import { BrowserModule } from '@angular/platform-browser';
-import { BrowserAnimationsModule } from '@angular/platform-browser/animations';
+import { AppComponent } from "./app.component";
 
-import { AppComponent } from './app.component';
+import { CalloutComponent } from "jslib-angular/components/callout.component";
+import { IconComponent } from "jslib-angular/components/icon.component";
+import { BitwardenToastModule } from "jslib-angular/components/toastr.component";
 
-import { CalloutComponent } from 'jslib/angular/components/callout.component';
-import { IconComponent } from 'jslib/angular/components/icon.component';
-import { ModalComponent } from 'jslib/angular/components/modal.component';
+import { ApiKeyComponent } from "./accounts/apiKey.component";
+import { EnvironmentComponent } from "./accounts/environment.component";
+import { DashboardComponent } from "./tabs/dashboard.component";
+import { MoreComponent } from "./tabs/more.component";
+import { SettingsComponent } from "./tabs/settings.component";
+import { TabsComponent } from "./tabs/tabs.component";
 
-import { EnvironmentComponent } from './accounts/environment.component';
-import { LoginComponent } from './accounts/login.component';
-import { SsoComponent } from './accounts/sso.component';
-import { TwoFactorOptionsComponent } from './accounts/two-factor-options.component';
-import { TwoFactorComponent } from './accounts/two-factor.component';
-import { DashboardComponent } from './tabs/dashboard.component';
-import { MoreComponent } from './tabs/more.component';
-import { SettingsComponent } from './tabs/settings.component';
-import { TabsComponent } from './tabs/tabs.component';
+import { A11yTitleDirective } from "jslib-angular/directives/a11y-title.directive";
+import { ApiActionDirective } from "jslib-angular/directives/api-action.directive";
+import { AutofocusDirective } from "jslib-angular/directives/autofocus.directive";
+import { BlurClickDirective } from "jslib-angular/directives/blur-click.directive";
+import { BoxRowDirective } from "jslib-angular/directives/box-row.directive";
+import { FallbackSrcDirective } from "jslib-angular/directives/fallback-src.directive";
+import { StopClickDirective } from "jslib-angular/directives/stop-click.directive";
+import { StopPropDirective } from "jslib-angular/directives/stop-prop.directive";
 
-import { A11yTitleDirective } from 'jslib/angular/directives/a11y-title.directive';
-import { ApiActionDirective } from 'jslib/angular/directives/api-action.directive';
-import { AutofocusDirective } from 'jslib/angular/directives/autofocus.directive';
-import { BlurClickDirective } from 'jslib/angular/directives/blur-click.directive';
-import { BoxRowDirective } from 'jslib/angular/directives/box-row.directive';
-import { FallbackSrcDirective } from 'jslib/angular/directives/fallback-src.directive';
-import { StopClickDirective } from 'jslib/angular/directives/stop-click.directive';
-import { StopPropDirective } from 'jslib/angular/directives/stop-prop.directive';
-
-import { I18nPipe } from 'jslib/angular/pipes/i18n.pipe';
-import { SearchCiphersPipe } from 'jslib/angular/pipes/search-ciphers.pipe';
+import { I18nPipe } from "jslib-angular/pipes/i18n.pipe";
+import { SearchCiphersPipe } from "jslib-angular/pipes/search-ciphers.pipe";
 
 @NgModule({
-    imports: [
-        BrowserModule,
-        BrowserAnimationsModule,
-        FormsModule,
-        AppRoutingModule,
-        ServicesModule,
-        ToasterModule.forRoot(),
-    ],
-    declarations: [
-        A11yTitleDirective,
-        ApiActionDirective,
-        AppComponent,
-        AutofocusDirective,
-        BlurClickDirective,
-        BoxRowDirective,
-        CalloutComponent,
-        DashboardComponent,
-        EnvironmentComponent,
-        FallbackSrcDirective,
-        I18nPipe,
-        IconComponent,
-        LoginComponent,
-        ModalComponent,
-        MoreComponent,
-        SearchCiphersPipe,
-        SettingsComponent,
-        SsoComponent,
-        StopClickDirective,
-        StopPropDirective,
-        TabsComponent,
-        TwoFactorComponent,
-        TwoFactorOptionsComponent,
-    ],
-    entryComponents: [
-        EnvironmentComponent,
-        ModalComponent,
-        TwoFactorOptionsComponent,
-    ],
-    providers: [],
-    bootstrap: [AppComponent],
+  imports: [
+    BrowserModule,
+    BrowserAnimationsModule,
+    FormsModule,
+    AppRoutingModule,
+    ServicesModule,
+    BitwardenToastModule.forRoot({
+      maxOpened: 5,
+      autoDismiss: true,
+      closeButton: true,
+    }),
+  ],
+  declarations: [
+    A11yTitleDirective,
+    ApiActionDirective,
+    ApiKeyComponent,
+    AppComponent,
+    AutofocusDirective,
+    BlurClickDirective,
+    BoxRowDirective,
+    CalloutComponent,
+    DashboardComponent,
+    EnvironmentComponent,
+    FallbackSrcDirective,
+    I18nPipe,
+    IconComponent,
+    MoreComponent,
+    SearchCiphersPipe,
+    SettingsComponent,
+    StopClickDirective,
+    StopPropDirective,
+    TabsComponent,
+  ],
+  providers: [],
+  bootstrap: [AppComponent],
 })
-export class AppModule { }
+export class AppModule {}

src/app/dummy.module.ts

@@ -1,16 +0,0 @@
-import { NgModule } from '@angular/core';
-
-import { InputVerbatimDirective } from 'jslib/angular/directives/input-verbatim.directive';
-import { TrueFalseValueDirective } from 'jslib/angular/directives/true-false-value.directive';
-import { SearchPipe } from 'jslib/angular/pipes/search.pipe';
-
-@NgModule({
-    imports: [],
-    declarations: [
-        InputVerbatimDirective,
-        TrueFalseValueDirective,
-        SearchPipe,
-    ],
-})
-export class DummyModule {
-}

src/app/main.ts

@@ -1,15 +1,15 @@
-import { enableProdMode } from '@angular/core';
-import { platformBrowserDynamic } from '@angular/platform-browser-dynamic';
+import { enableProdMode } from "@angular/core";
+import { platformBrowserDynamic } from "@angular/platform-browser-dynamic";
 
-import { isDev } from 'jslib/electron/utils';
+import { isDev } from "jslib-electron/utils";
 
 // tslint:disable-next-line
-require('../scss/styles.scss');
+require("../scss/styles.scss");
 
-import { AppModule } from './app.module';
+import { AppModule } from "./app.module";
 
 if (!isDev()) {
-    enableProdMode();
+  enableProdMode();
 }
 
 platformBrowserDynamic().bootstrapModule(AppModule, { preserveWhitespaces: true });

src/app/services/auth-guard.service.ts

@@ -1,24 +1,21 @@
-import { Injectable } from '@angular/core';
-import {
-    CanActivate,
-    Router,
-} from '@angular/router';
+import { Injectable } from "@angular/core";
+import { CanActivate } from "@angular/router";
 
-import { MessagingService } from 'jslib/abstractions/messaging.service';
-import { UserService } from 'jslib/abstractions/user.service';
+import { MessagingService } from "jslib-common/abstractions/messaging.service";
+
+import { StateService } from "../../abstractions/state.service";
 
 @Injectable()
 export class AuthGuardService implements CanActivate {
-    constructor(private userService: UserService, private router: Router,
-        private messagingService: MessagingService) { }
+  constructor(private stateService: StateService, private messagingService: MessagingService) {}
 
-    async canActivate() {
-        const isAuthed = await this.userService.isAuthenticated();
-        if (!isAuthed) {
-            this.messagingService.send('logout');
-            return false;
-        }
-
-        return true;
+  async canActivate() {
+    const isAuthed = await this.stateService.getIsAuthenticated();
+    if (!isAuthed) {
+      this.messagingService.send("logout");
+      return false;
     }
+
+    return true;
+  }
 }

src/app/services/launch-guard.service.ts

@@ -1,22 +1,19 @@
-import { Injectable } from '@angular/core';
-import {
-    CanActivate,
-    Router,
-} from '@angular/router';
+import { Injectable } from "@angular/core";
+import { CanActivate, Router } from "@angular/router";
 
-import { UserService } from 'jslib/abstractions/user.service';
+import { StateService } from "../../abstractions/state.service";
 
 @Injectable()
 export class LaunchGuardService implements CanActivate {
-    constructor(private userService: UserService, private router: Router) { }
+  constructor(private stateService: StateService, private router: Router) {}
 
-    async canActivate() {
-        const isAuthed = await this.userService.isAuthenticated();
-        if (!isAuthed) {
-            return true;
-        }
-
-        this.router.navigate(['/tabs/dashboard']);
-        return false;
+  async canActivate() {
+    const isAuthed = await this.stateService.getIsAuthenticated();
+    if (!isAuthed) {
+      return true;
     }
+
+    this.router.navigate(["/tabs/dashboard"]);
+    return false;
+  }
 }

src/app/services/services.module.ts

@@ -1,152 +1,237 @@
-import {
-    APP_INITIALIZER,
-    NgModule,
-} from '@angular/core';
+import { APP_INITIALIZER, Injector, NgModule } from "@angular/core";
 
-import { ToasterModule } from 'angular2-toaster';
+import { ElectronLogService } from "jslib-electron/services/electronLog.service";
+import { ElectronPlatformUtilsService } from "jslib-electron/services/electronPlatformUtils.service";
+import { ElectronRendererMessagingService } from "jslib-electron/services/electronRendererMessaging.service";
+import { ElectronRendererSecureStorageService } from "jslib-electron/services/electronRendererSecureStorage.service";
+import { ElectronRendererStorageService } from "jslib-electron/services/electronRendererStorage.service";
 
-import { ElectronLogService } from 'jslib/electron/services/electronLog.service';
-import { ElectronPlatformUtilsService } from 'jslib/electron/services/electronPlatformUtils.service';
-import { ElectronRendererMessagingService } from 'jslib/electron/services/electronRendererMessaging.service';
-import { ElectronRendererSecureStorageService } from 'jslib/electron/services/electronRendererSecureStorage.service';
-import { ElectronRendererStorageService } from 'jslib/electron/services/electronRendererStorage.service';
+import { AuthGuardService } from "./auth-guard.service";
+import { LaunchGuardService } from "./launch-guard.service";
 
-import { AuthGuardService } from './auth-guard.service';
-import { LaunchGuardService } from './launch-guard.service';
+import { I18nService } from "../../services/i18n.service";
+import { SyncService } from "../../services/sync.service";
 
-import { ConfigurationService } from '../../services/configuration.service';
-import { I18nService } from '../../services/i18n.service';
-import { SyncService } from '../../services/sync.service';
+import { JslibServicesModule } from "jslib-angular/services/jslib-services.module";
 
-import { BroadcasterService } from 'jslib/angular/services/broadcaster.service';
-import { ValidationService } from 'jslib/angular/services/validation.service';
+import { ContainerService } from "jslib-common/services/container.service";
 
-import { ApiService } from 'jslib/services/api.service';
-import { AppIdService } from 'jslib/services/appId.service';
-import { AuthService } from 'jslib/services/auth.service';
-import { ConstantsService } from 'jslib/services/constants.service';
-import { ContainerService } from 'jslib/services/container.service';
-import { CryptoService } from 'jslib/services/crypto.service';
-import { EnvironmentService } from 'jslib/services/environment.service';
-import { NodeCryptoFunctionService } from 'jslib/services/nodeCryptoFunction.service';
-import { PasswordGenerationService } from 'jslib/services/passwordGeneration.service';
-import { PolicyService } from 'jslib/services/policy.service';
-import { StateService } from 'jslib/services/state.service';
-import { TokenService } from 'jslib/services/token.service';
-import { UserService } from 'jslib/services/user.service';
+import { NodeApiService } from "jslib-node/services/nodeApi.service";
+import { NodeCryptoFunctionService } from "jslib-node/services/nodeCryptoFunction.service";
 
-import { ApiService as ApiServiceAbstraction } from 'jslib/abstractions/api.service';
-import { AuthService as AuthServiceAbstraction } from 'jslib/abstractions/auth.service';
-import { CryptoService as CryptoServiceAbstraction } from 'jslib/abstractions/crypto.service';
-import { CryptoFunctionService as CryptoFunctionServiceAbstraction } from 'jslib/abstractions/cryptoFunction.service';
-import { EnvironmentService as EnvironmentServiceAbstraction } from 'jslib/abstractions/environment.service';
-import { I18nService as I18nServiceAbstraction } from 'jslib/abstractions/i18n.service';
-import { LogService as LogServiceAbstraction } from 'jslib/abstractions/log.service';
-import { MessagingService as MessagingServiceAbstraction } from 'jslib/abstractions/messaging.service';
-import {
-    PasswordGenerationService as PasswordGenerationServiceAbstraction,
-} from 'jslib/abstractions/passwordGeneration.service';
-import { PlatformUtilsService as PlatformUtilsServiceAbstraction } from 'jslib/abstractions/platformUtils.service';
-import { PolicyService as PolicyServiceAbstraction } from 'jslib/abstractions/policy.service';
-import { StateService as StateServiceAbstraction } from 'jslib/abstractions/state.service';
-import { StorageService as StorageServiceAbstraction } from 'jslib/abstractions/storage.service';
-import { TokenService as TokenServiceAbstraction } from 'jslib/abstractions/token.service';
-import { UserService as UserServiceAbstraction } from 'jslib/abstractions/user.service';
+import { ApiService as ApiServiceAbstraction } from "jslib-common/abstractions/api.service";
+import { AppIdService as AppIdServiceAbstraction } from "jslib-common/abstractions/appId.service";
+import { AuthService as AuthServiceAbstraction } from "jslib-common/abstractions/auth.service";
+import { BroadcasterService as BroadcasterServiceAbstraction } from "jslib-common/abstractions/broadcaster.service";
+import { CryptoService as CryptoServiceAbstraction } from "jslib-common/abstractions/crypto.service";
+import { CryptoFunctionService as CryptoFunctionServiceAbstraction } from "jslib-common/abstractions/cryptoFunction.service";
+import { EnvironmentService as EnvironmentServiceAbstraction } from "jslib-common/abstractions/environment.service";
+import { I18nService as I18nServiceAbstraction } from "jslib-common/abstractions/i18n.service";
+import { KeyConnectorService as KeyConnectorServiceAbstraction } from "jslib-common/abstractions/keyConnector.service";
+import { LogService as LogServiceAbstraction } from "jslib-common/abstractions/log.service";
+import { MessagingService as MessagingServiceAbstraction } from "jslib-common/abstractions/messaging.service";
+import { PlatformUtilsService as PlatformUtilsServiceAbstraction } from "jslib-common/abstractions/platformUtils.service";
+import { StateMigrationService as StateMigrationServiceAbstraction } from "jslib-common/abstractions/stateMigration.service";
+import { StorageService as StorageServiceAbstraction } from "jslib-common/abstractions/storage.service";
+import { TokenService as TokenServiceAbstraction } from "jslib-common/abstractions/token.service";
+import { VaultTimeoutService as VaultTimeoutServiceAbstraction } from "jslib-common/abstractions/vaultTimeout.service";
 
-const logService = new ElectronLogService();
-const i18nService = new I18nService(window.navigator.language, './locales');
-const stateService = new StateService();
-const broadcasterService = new BroadcasterService();
-const messagingService = new ElectronRendererMessagingService(broadcasterService);
-const storageService: StorageServiceAbstraction = new ElectronRendererStorageService();
-const platformUtilsService = new ElectronPlatformUtilsService(i18nService, messagingService, false, storageService);
-const secureStorageService: StorageServiceAbstraction = new ElectronRendererSecureStorageService();
-const cryptoFunctionService: CryptoFunctionServiceAbstraction = new NodeCryptoFunctionService();
-const cryptoService = new CryptoService(storageService, secureStorageService, cryptoFunctionService,
-    platformUtilsService, logService);
-const appIdService = new AppIdService(storageService);
-const tokenService = new TokenService(storageService);
-const apiService = new ApiService(tokenService, platformUtilsService,
-    async (expired: boolean) => messagingService.send('logout', { expired: expired }));
-const environmentService = new EnvironmentService(apiService, storageService, null);
-const userService = new UserService(tokenService, storageService);
-const containerService = new ContainerService(cryptoService);
-const authService = new AuthService(cryptoService, apiService, userService, tokenService, appIdService,
-    i18nService, platformUtilsService, messagingService, null, logService, false);
-const configurationService = new ConfigurationService(storageService, secureStorageService);
-const syncService = new SyncService(configurationService, logService, cryptoFunctionService, apiService,
-    messagingService, i18nService);
-const passwordGenerationService = new PasswordGenerationService(cryptoService, storageService, null);
-const policyService = new PolicyService(userService, storageService);
+import { StateService as StateServiceAbstraction } from "../../abstractions/state.service";
 
-containerService.attachToWindow(window);
+import { ApiService, refreshToken } from "../../services/api.service";
+import { AuthService } from "../../services/auth.service";
+import { StateService } from "../../services/state.service";
+import { StateMigrationService } from "../../services/stateMigration.service";
 
-export function initFactory(): Function {
-    return async () => {
-        await environmentService.setUrlsFromStorage();
-        await i18nService.init();
-        authService.init();
-        const htmlEl = window.document.documentElement;
-        htmlEl.classList.add('os_' + platformUtilsService.getDeviceString());
-        htmlEl.classList.add('locale_' + i18nService.translationLocale);
-        window.document.title = i18nService.t('bitwardenDirectoryConnector');
+import { Account } from "../../models/account";
 
-        let installAction = null;
-        const installedVersion = await storageService.get<string>(ConstantsService.installedVersionKey);
-        const currentVersion = await platformUtilsService.getApplicationVersion();
-        if (installedVersion == null) {
-            installAction = 'install';
-        } else if (installedVersion !== currentVersion) {
-            installAction = 'update';
-        }
+import { StateFactory } from "jslib-common/factories/stateFactory";
 
-        if (installAction != null) {
-            await storageService.save(ConstantsService.installedVersionKey, currentVersion);
-        }
+import { GlobalState } from "jslib-common/models/domain/globalState";
 
-        window.setTimeout(async () => {
-            if (await userService.isAuthenticated()) {
-                const profile = await apiService.getProfile();
-                stateService.save('profileOrganizations', profile.organizations);
-            }
-        }, 500);
-    };
+function refreshTokenCallback(injector: Injector) {
+  return () => {
+    const stateService = injector.get(StateServiceAbstraction);
+    const authService = injector.get(AuthServiceAbstraction);
+    return refreshToken(stateService, authService);
+  };
+}
+
+export function initFactory(
+  environmentService: EnvironmentServiceAbstraction,
+  i18nService: I18nService,
+  authService: AuthService,
+  platformUtilsService: PlatformUtilsServiceAbstraction,
+  stateService: StateServiceAbstraction,
+  cryptoService: CryptoServiceAbstraction
+): Function {
+  return async () => {
+    await stateService.init();
+    await environmentService.setUrlsFromStorage();
+    await i18nService.init();
+    authService.init();
+    const htmlEl = window.document.documentElement;
+    htmlEl.classList.add("os_" + platformUtilsService.getDeviceString());
+    htmlEl.classList.add("locale_" + i18nService.translationLocale);
+    window.document.title = i18nService.t("bitwardenDirectoryConnector");
+
+    let installAction = null;
+    const installedVersion = await stateService.getInstalledVersion();
+    const currentVersion = await platformUtilsService.getApplicationVersion();
+    if (installedVersion == null) {
+      installAction = "install";
+    } else if (installedVersion !== currentVersion) {
+      installAction = "update";
+    }
+
+    if (installAction != null) {
+      await stateService.setInstalledVersion(currentVersion);
+    }
+
+    const containerService = new ContainerService(cryptoService);
+    containerService.attachToWindow(window);
+  };
 }
 
 @NgModule({
-    imports: [
-        ToasterModule,
-    ],
-    declarations: [],
-    providers: [
-        ValidationService,
-        AuthGuardService,
-        LaunchGuardService,
-        { provide: AuthServiceAbstraction, useValue: authService },
-        { provide: EnvironmentServiceAbstraction, useValue: environmentService },
-        { provide: TokenServiceAbstraction, useValue: tokenService },
-        { provide: I18nServiceAbstraction, useValue: i18nService },
-        { provide: CryptoServiceAbstraction, useValue: cryptoService },
-        { provide: PlatformUtilsServiceAbstraction, useValue: platformUtilsService },
-        { provide: ApiServiceAbstraction, useValue: apiService },
-        { provide: UserServiceAbstraction, useValue: userService },
-        { provide: MessagingServiceAbstraction, useValue: messagingService },
-        { provide: BroadcasterService, useValue: broadcasterService },
-        { provide: StorageServiceAbstraction, useValue: storageService },
-        { provide: StateServiceAbstraction, useValue: stateService },
-        { provide: LogServiceAbstraction, useValue: logService },
-        { provide: ConfigurationService, useValue: configurationService },
-        { provide: SyncService, useValue: syncService },
-        { provide: PasswordGenerationServiceAbstraction, useValue: passwordGenerationService },
-        { provide: CryptoFunctionServiceAbstraction, useValue: cryptoFunctionService },
-        { provide: PolicyServiceAbstraction, useValue: policyService },
-        {
-            provide: APP_INITIALIZER,
-            useFactory: initFactory,
-            deps: [],
-            multi: true,
-        },
-    ],
+  imports: [JslibServicesModule],
+  declarations: [],
+  providers: [
+    {
+      provide: APP_INITIALIZER,
+      useFactory: initFactory,
+      deps: [
+        EnvironmentServiceAbstraction,
+        I18nServiceAbstraction,
+        AuthServiceAbstraction,
+        PlatformUtilsServiceAbstraction,
+        StateServiceAbstraction,
+        CryptoServiceAbstraction,
+      ],
+      multi: true,
+    },
+    { provide: LogServiceAbstraction, useClass: ElectronLogService, deps: [] },
+    {
+      provide: I18nServiceAbstraction,
+      useFactory: (window: Window) => new I18nService(window.navigator.language, "./locales"),
+      deps: ["WINDOW"],
+    },
+    {
+      provide: MessagingServiceAbstraction,
+      useClass: ElectronRendererMessagingService,
+      deps: [BroadcasterServiceAbstraction],
+    },
+    { provide: StorageServiceAbstraction, useClass: ElectronRendererStorageService },
+    { provide: "SECURE_STORAGE", useClass: ElectronRendererSecureStorageService },
+    {
+      provide: PlatformUtilsServiceAbstraction,
+      useFactory: (
+        i18nService: I18nServiceAbstraction,
+        messagingService: MessagingServiceAbstraction,
+        stateService: StateServiceAbstraction
+      ) => new ElectronPlatformUtilsService(i18nService, messagingService, true, stateService),
+      deps: [I18nServiceAbstraction, MessagingServiceAbstraction, StateServiceAbstraction],
+    },
+    { provide: CryptoFunctionServiceAbstraction, useClass: NodeCryptoFunctionService, deps: [] },
+    {
+      provide: ApiServiceAbstraction,
+      useFactory: (
+        tokenService: TokenServiceAbstraction,
+        platformUtilsService: PlatformUtilsServiceAbstraction,
+        environmentService: EnvironmentServiceAbstraction,
+        messagingService: MessagingServiceAbstraction,
+        injector: Injector
+      ) =>
+        new NodeApiService(
+          tokenService,
+          platformUtilsService,
+          environmentService,
+          async (expired: boolean) => messagingService.send("logout", { expired: expired }),
+          "Bitwarden_DC/" +
+            platformUtilsService.getApplicationVersion() +
+            " (" +
+            platformUtilsService.getDeviceString().toUpperCase() +
+            ")",
+          refreshTokenCallback(injector)
+        ),
+      deps: [
+        TokenServiceAbstraction,
+        PlatformUtilsServiceAbstraction,
+        EnvironmentServiceAbstraction,
+        MessagingServiceAbstraction,
+        Injector,
+      ],
+    },
+    {
+      provide: AuthServiceAbstraction,
+      useClass: AuthService,
+      deps: [
+        CryptoServiceAbstraction,
+        ApiServiceAbstraction,
+        TokenServiceAbstraction,
+        AppIdServiceAbstraction,
+        I18nServiceAbstraction,
+        PlatformUtilsServiceAbstraction,
+        MessagingServiceAbstraction,
+        VaultTimeoutServiceAbstraction,
+        LogServiceAbstraction,
+        CryptoFunctionServiceAbstraction,
+        EnvironmentServiceAbstraction,
+        KeyConnectorServiceAbstraction,
+        StateServiceAbstraction,
+      ],
+    },
+    {
+      provide: SyncService,
+      useClass: SyncService,
+      deps: [
+        LogServiceAbstraction,
+        CryptoFunctionServiceAbstraction,
+        ApiServiceAbstraction,
+        MessagingServiceAbstraction,
+        I18nServiceAbstraction,
+        EnvironmentServiceAbstraction,
+        StateServiceAbstraction,
+      ],
+    },
+    AuthGuardService,
+    LaunchGuardService,
+    {
+      provide: StateMigrationServiceAbstraction,
+      useFactory: (
+        storageService: StorageServiceAbstraction,
+        secureStorageService: StorageServiceAbstraction
+      ) =>
+        new StateMigrationService(
+          storageService,
+          secureStorageService,
+          new StateFactory(GlobalState, Account)
+        ),
+      deps: [StorageServiceAbstraction, "SECURE_STORAGE"],
+    },
+    {
+      provide: StateServiceAbstraction,
+      useFactory: (
+        storageService: StorageServiceAbstraction,
+        secureStorageService: StorageServiceAbstraction,
+        logService: LogServiceAbstraction,
+        stateMigrationService: StateMigrationServiceAbstraction
+      ) =>
+        new StateService(
+          storageService,
+          secureStorageService,
+          logService,
+          stateMigrationService,
+          true,
+          new StateFactory(GlobalState, Account)
+        ),
+      deps: [
+        StorageServiceAbstraction,
+        "SECURE_STORAGE",
+        LogServiceAbstraction,
+        StateMigrationServiceAbstraction,
+      ],
+    },
+  ],
 })
-export class ServicesModule {
-}
+export class ServicesModule {}

src/app/tabs/dashboard.component.html

@@ -1,99 +1,110 @@
 <div class="card mb-3">
-    <h3 class="card-header">{{'sync' | i18n}}</h3>
-    <div class="card-body">
-        <p>
-            {{'lastGroupSync' | i18n}}:
-            <span *ngIf="!lastGroupSync">-</span>
-            {{lastGroupSync | date:'medium'}}
-            <br /> {{'lastUserSync' | i18n}}:
-            <span *ngIf="!lastUserSync">-</span>
-            {{lastUserSync | date:'medium'}}
-        </p>
-        <p>
-            {{'syncStatus' | i18n}}:
-            <strong *ngIf="syncRunning" class="text-success">{{'running' | i18n}}</strong>
-            <strong *ngIf="!syncRunning" class="text-danger">{{'stopped' | i18n}}</strong>
-        </p>
-        <form #startForm [appApiAction]="startPromise" class="d-inline">
-            <button (click)="start()" class="btn btn-primary"
-                [disabled]="startForm.loading">
-                <i class="fa fa-play fa-fw" [hidden]="startForm.loading"></i>
-                <i class="fa fa-spinner fa-fw fa-spin" [hidden]="!startForm.loading"></i>
-                {{'startSync' | i18n}}
-            </button>
-        </form>
-        <button (click)="stop()" class="btn btn-primary">
-            <i class="fa fa-stop fa-fw"></i>
-            {{'stopSync' | i18n}}
-        </button>
-        <form #syncForm [appApiAction]="syncPromise" class="d-inline">
-            <button (click)="sync()" class="btn btn-primary"
-                [disabled]="syncForm.loading">
-                <i class="fa fa-refresh fa-fw" [ngClass]="{'fa-spin': syncForm.loading}"></i>
-                {{'syncNow' | i18n}}
-            </button>
-        </form>
-    </div>
+  <h3 class="card-header">{{ "sync" | i18n }}</h3>
+  <div class="card-body">
+    <p>
+      {{ "lastGroupSync" | i18n }}:
+      <span *ngIf="!lastGroupSync">-</span>
+      {{ lastGroupSync | date: "medium" }}
+      <br />
+      {{ "lastUserSync" | i18n }}:
+      <span *ngIf="!lastUserSync">-</span>
+      {{ lastUserSync | date: "medium" }}
+    </p>
+    <p>
+      {{ "syncStatus" | i18n }}:
+      <strong *ngIf="syncRunning" class="text-success">{{ "running" | i18n }}</strong>
+      <strong *ngIf="!syncRunning" class="text-danger">{{ "stopped" | i18n }}</strong>
+    </p>
+    <form #startForm [appApiAction]="startPromise" class="d-inline">
+      <button (click)="start()" class="btn btn-primary" [disabled]="startForm.loading">
+        <i class="bwi bwi-play bwi-fw" [hidden]="startForm.loading"></i>
+        <i class="bwi bwi-spinner bwi-fw bwi-spin" [hidden]="!startForm.loading"></i>
+        {{ "startSync" | i18n }}
+      </button>
+    </form>
+    <button (click)="stop()" class="btn btn-primary">
+      <i class="bwi bwi-stop bwi-fw"></i>
+      {{ "stopSync" | i18n }}
+    </button>
+    <form #syncForm [appApiAction]="syncPromise" class="d-inline">
+      <button (click)="sync()" class="btn btn-primary" [disabled]="syncForm.loading">
+        <i class="bwi bwi-refresh bwi-fw" [ngClass]="{ 'bwi-spin': syncForm.loading }"></i>
+        {{ "syncNow" | i18n }}
+      </button>
+    </form>
+  </div>
 </div>
 <div class="card">
-    <h3 class="card-header">{{'testing' | i18n}}</h3>
-    <div class="card-body">
-        <p>{{'testingDesc' | i18n}}</p>
-        <form #simForm [appApiAction]="simPromise" class="d-inline">
-            <button (click)="simulate()" class="btn btn-primary"
-                [disabled]="simForm.loading">
-                <i class="fa fa-spinner fa-fw fa-spin" [hidden]="!simForm.loading"></i>
-                <i class="fa fa-bug fa-fw" [hidden]="simForm.loading"></i>
-                {{'testNow' | i18n}}
-            </button>
-        </form>
-        <div class="form-check mt-2">
-            <input class="form-check-input" type="checkbox" id="simSinceLast" [(ngModel)]="simSinceLast">
-            <label class="form-check-label" for="simSinceLast">{{'testLastSync' | i18n}}</label>
-        </div>
-        <ng-container *ngIf="!simForm.loading && (simUsers || simGroups)">
-            <hr />
-            <div class="row">
-                <div class="col-lg">
-                    <h4>{{'users' | i18n}}</h4>
-                    <ul class="fa-ul testing-list" *ngIf="simEnabledUsers && simEnabledUsers.length">
-                        <li *ngFor="let u of simEnabledUsers" title="{{u.referenceId}}">
-                            <i class="fa-li fa fa-user"></i>
-                            {{u.displayName}}
-                        </li>
-                    </ul>
-                    <p *ngIf="!simEnabledUsers || !simEnabledUsers.length">{{'noUsers' | i18n}}</p>
-                    <h4>{{'disabledUsers' | i18n}}</h4>
-                    <ul class="fa-ul testing-list" *ngIf="simDisabledUsers && simDisabledUsers.length">
-                        <li *ngFor="let u of simDisabledUsers" title="{{u.referenceId}}">
-                            <i class="fa-li fa fa-user"></i>
-                            {{u.displayName}}
-                        </li>
-                    </ul>
-                    <p *ngIf="!simDisabledUsers || !simDisabledUsers.length">{{'noUsers' | i18n}}</p>
-                    <h4>{{'deletedUsers' | i18n}}</h4>
-                    <ul class="fa-ul testing-list" *ngIf="simDeletedUsers && simDeletedUsers.length">
-                        <li *ngFor="let u of simDeletedUsers" title="{{u.referenceId}}">
-                            <i class="fa-li fa fa-user"></i>
-                            {{u.displayName}}
-                        </li>
-                    </ul>
-                    <p *ngIf="!simDeletedUsers || !simDeletedUsers.length">{{'noUsers' | i18n}}</p>
-                </div>
-                <div class="col-lg">
-                    <h4>{{'groups' | i18n}}</h4>
-                    <ul class="fa-ul testing-list" *ngIf="simGroups && simGroups.length">
-                        <li *ngFor="let g of simGroups" title="{{g.referenceId}}">
-                            <i class="fa-li fa fa-sitemap"></i>
-                            {{g.displayName}}
-                            <ul class="small" *ngIf="g.users && g.users.length">
-                                <li *ngFor="let u of g.users" title="{{u.referenceId}}">{{u.displayName}}</li>
-                            </ul>
-                        </li>
-                    </ul>
-                    <p *ngIf="!simGroups || !simGroups.length">{{'noGroups' | i18n}}</p>
-                </div>
-            </div>
-        </ng-container>
+  <h3 class="card-header">{{ "testing" | i18n }}</h3>
+  <div class="card-body">
+    <p>{{ "testingDesc" | i18n }}</p>
+    <form #simForm [appApiAction]="simPromise" class="d-inline">
+      <button (click)="simulate()" class="btn btn-primary" [disabled]="simForm.loading">
+        <i class="bwi bwi-spinner bwi-fw bwi-spin" [hidden]="!simForm.loading"></i>
+        <i class="bwi bwi-bug bwi-fw" [hidden]="simForm.loading"></i>
+        {{ "testNow" | i18n }}
+      </button>
+    </form>
+    <div class="form-check mt-2">
+      <input
+        class="form-check-input"
+        type="checkbox"
+        id="simSinceLast"
+        [(ngModel)]="simSinceLast"
+      />
+      <label class="form-check-label" for="simSinceLast">{{ "testLastSync" | i18n }}</label>
     </div>
+    <ng-container *ngIf="!simForm.loading && (simUsers || simGroups)">
+      <hr />
+      <div class="row">
+        <div class="col-lg">
+          <h4>{{ "users" | i18n }}</h4>
+          <ul class="bwi-ul testing-list" *ngIf="simEnabledUsers && simEnabledUsers.length">
+            <li *ngFor="let u of simEnabledUsers" title="{{ u.referenceId }}">
+              <i class="bwi bwi-li bwi-user"></i>
+              {{ u.displayName }}
+            </li>
+          </ul>
+          <p *ngIf="!simEnabledUsers || !simEnabledUsers.length">
+            {{ "noUsers" | i18n }}
+          </p>
+          <h4>{{ "disabledUsers" | i18n }}</h4>
+          <ul class="bwi-ul testing-list" *ngIf="simDisabledUsers && simDisabledUsers.length">
+            <li *ngFor="let u of simDisabledUsers" title="{{ u.referenceId }}">
+              <i class="bwi bwi-li bwi-user"></i>
+              {{ u.displayName }}
+            </li>
+          </ul>
+          <p *ngIf="!simDisabledUsers || !simDisabledUsers.length">
+            {{ "noUsers" | i18n }}
+          </p>
+          <h4>{{ "deletedUsers" | i18n }}</h4>
+          <ul class="bwi-ul testing-list" *ngIf="simDeletedUsers && simDeletedUsers.length">
+            <li *ngFor="let u of simDeletedUsers" title="{{ u.referenceId }}">
+              <i class="bwi bwi-li bwi-user"></i>
+              {{ u.displayName }}
+            </li>
+          </ul>
+          <p *ngIf="!simDeletedUsers || !simDeletedUsers.length">
+            {{ "noUsers" | i18n }}
+          </p>
+        </div>
+        <div class="col-lg">
+          <h4>{{ "groups" | i18n }}</h4>
+          <ul class="bwi-ul testing-list" *ngIf="simGroups && simGroups.length">
+            <li *ngFor="let g of simGroups" title="{{ g.referenceId }}">
+              <i class="bwi bwi-li bwi-sitemap"></i>
+              {{ g.displayName }}
+              <ul class="small" *ngIf="g.users && g.users.length">
+                <li *ngFor="let u of g.users" title="{{ u.referenceId }}">
+                  {{ u.displayName }}
+                </li>
+              </ul>
+            </li>
+          </ul>
+          <p *ngIf="!simGroups || !simGroups.length">{{ "noGroups" | i18n }}</p>
+        </div>
+      </div>
+    </ng-container>
+  </div>
 </div>

src/app/tabs/dashboard.component.ts

@@ -1,123 +1,127 @@
-import {
-    ChangeDetectorRef,
-    Component,
-    NgZone,
-    OnDestroy,
-    OnInit,
-} from '@angular/core';
+import { ChangeDetectorRef, Component, NgZone, OnDestroy, OnInit } from "@angular/core";
 
-import { ToasterService } from 'angular2-toaster';
+import { BroadcasterService } from "jslib-common/abstractions/broadcaster.service";
+import { I18nService } from "jslib-common/abstractions/i18n.service";
+import { MessagingService } from "jslib-common/abstractions/messaging.service";
+import { PlatformUtilsService } from "jslib-common/abstractions/platformUtils.service";
 
-import { I18nService } from 'jslib/abstractions/i18n.service';
-import { MessagingService } from 'jslib/abstractions/messaging.service';
-import { StateService } from 'jslib/abstractions/state.service';
+import { SyncService } from "../../services/sync.service";
 
-import { SyncService } from '../../services/sync.service';
+import { GroupEntry } from "../../models/groupEntry";
+import { SimResult } from "../../models/simResult";
+import { UserEntry } from "../../models/userEntry";
 
-import { GroupEntry } from '../../models/groupEntry';
-import { SimResult } from '../../models/simResult';
-import { UserEntry } from '../../models/userEntry';
-import { ConfigurationService } from '../../services/configuration.service';
+import { ConnectorUtils } from "../../utils";
 
-import { BroadcasterService } from 'jslib/angular/services/broadcaster.service';
+import { StateService } from "../../abstractions/state.service";
 
-import { ConnectorUtils } from '../../utils';
-
-const BroadcasterSubscriptionId = 'DashboardComponent';
+const BroadcasterSubscriptionId = "DashboardComponent";
 
 @Component({
-    selector: 'app-dashboard',
-    templateUrl: 'dashboard.component.html',
+  selector: "app-dashboard",
+  templateUrl: "dashboard.component.html",
 })
 export class DashboardComponent implements OnInit, OnDestroy {
-    simGroups: GroupEntry[];
-    simUsers: UserEntry[];
-    simEnabledUsers: UserEntry[] = [];
-    simDisabledUsers: UserEntry[] = [];
-    simDeletedUsers: UserEntry[] = [];
-    simPromise: Promise<SimResult>;
-    simSinceLast: boolean = false;
-    syncPromise: Promise<[GroupEntry[], UserEntry[]]>;
-    startPromise: Promise<any>;
-    lastGroupSync: Date;
-    lastUserSync: Date;
-    syncRunning: boolean;
+  simGroups: GroupEntry[];
+  simUsers: UserEntry[];
+  simEnabledUsers: UserEntry[] = [];
+  simDisabledUsers: UserEntry[] = [];
+  simDeletedUsers: UserEntry[] = [];
+  simPromise: Promise<SimResult>;
+  simSinceLast: boolean = false;
+  syncPromise: Promise<[GroupEntry[], UserEntry[]]>;
+  startPromise: Promise<any>;
+  lastGroupSync: Date;
+  lastUserSync: Date;
+  syncRunning: boolean;
 
-    constructor(private i18nService: I18nService, private syncService: SyncService,
-        private configurationService: ConfigurationService, private broadcasterService: BroadcasterService,
-        private ngZone: NgZone, private messagingService: MessagingService,
-        private toasterService: ToasterService, private changeDetectorRef: ChangeDetectorRef,
-        private stateService: StateService) { }
+  constructor(
+    private i18nService: I18nService,
+    private syncService: SyncService,
+    private broadcasterService: BroadcasterService,
+    private ngZone: NgZone,
+    private messagingService: MessagingService,
+    private platformUtilsService: PlatformUtilsService,
+    private changeDetectorRef: ChangeDetectorRef,
+    private stateService: StateService
+  ) {}
 
-    async ngOnInit() {
-        this.broadcasterService.subscribe(BroadcasterSubscriptionId, async (message: any) => {
-            this.ngZone.run(async () => {
-                switch (message.command) {
-                    case 'dirSyncCompleted':
-                        this.updateLastSync();
-                        break;
-                    default:
-                        break;
-                }
-
-                this.changeDetectorRef.detectChanges();
-            });
-        });
-
-        this.syncRunning = !!(await this.stateService.get('syncingDir'));
-        this.updateLastSync();
-    }
-
-    async ngOnDestroy() {
-        this.broadcasterService.unsubscribe(BroadcasterSubscriptionId);
-    }
-
-    async start() {
-        this.startPromise = this.syncService.sync(false, false);
-        await this.startPromise;
-        this.messagingService.send('scheduleNextDirSync');
-        this.syncRunning = true;
-        this.toasterService.popAsync('success', null, this.i18nService.t('syncingStarted'));
-    }
-
-    async stop() {
-        this.messagingService.send('cancelDirSync');
-        this.syncRunning = false;
-        this.toasterService.popAsync('success', null, this.i18nService.t('syncingStopped'));
-    }
-
-    async sync() {
-        this.syncPromise = this.syncService.sync(false, false);
-        const result = await this.syncPromise;
-        const groupCount = result[0] != null ? result[0].length : 0;
-        const userCount = result[1] != null ? result[1].length : 0;
-        this.toasterService.popAsync('success', null,
-            this.i18nService.t('syncCounts', groupCount.toString(), userCount.toString()));
-    }
-
-    async simulate() {
-        this.simGroups = [];
-        this.simUsers = [];
-        this.simEnabledUsers = [];
-        this.simDisabledUsers = [];
-        this.simDeletedUsers = [];
-
-        try {
-            this.simPromise = ConnectorUtils.simulate(this.syncService, this.i18nService, this.simSinceLast);
-            const result = await this.simPromise;
-            this.simGroups = result.groups;
-            this.simUsers = result.users;
-            this.simEnabledUsers = result.enabledUsers;
-            this.simDisabledUsers = result.disabledUsers;
-            this.simDeletedUsers = result.deletedUsers;
-        } catch (e) {
-            this.simGroups = null;
-            this.simUsers = null;
+  async ngOnInit() {
+    this.broadcasterService.subscribe(BroadcasterSubscriptionId, async (message: any) => {
+      this.ngZone.run(async () => {
+        switch (message.command) {
+          case "dirSyncCompleted":
+            this.updateLastSync();
+            break;
+          default:
+            break;
         }
-    }
 
-    private async updateLastSync() {
-        this.lastGroupSync = await this.configurationService.getLastGroupSyncDate();
-        this.lastUserSync = await this.configurationService.getLastUserSyncDate();
+        this.changeDetectorRef.detectChanges();
+      });
+    });
+
+    this.syncRunning = !!(await this.stateService.getSyncingDir());
+    this.updateLastSync();
+  }
+
+  async ngOnDestroy() {
+    this.broadcasterService.unsubscribe(BroadcasterSubscriptionId);
+  }
+
+  async start() {
+    this.startPromise = this.syncService.sync(false, false);
+    await this.startPromise;
+    this.messagingService.send("scheduleNextDirSync");
+    this.syncRunning = true;
+    this.platformUtilsService.showToast("success", null, this.i18nService.t("syncingStarted"));
+  }
+
+  async stop() {
+    this.messagingService.send("cancelDirSync");
+    this.syncRunning = false;
+    this.platformUtilsService.showToast("success", null, this.i18nService.t("syncingStopped"));
+  }
+
+  async sync() {
+    this.syncPromise = this.syncService.sync(false, false);
+    const result = await this.syncPromise;
+    const groupCount = result[0] != null ? result[0].length : 0;
+    const userCount = result[1] != null ? result[1].length : 0;
+    this.platformUtilsService.showToast(
+      "success",
+      null,
+      this.i18nService.t("syncCounts", groupCount.toString(), userCount.toString())
+    );
+  }
+
+  async simulate() {
+    this.simGroups = [];
+    this.simUsers = [];
+    this.simEnabledUsers = [];
+    this.simDisabledUsers = [];
+    this.simDeletedUsers = [];
+
+    try {
+      this.simPromise = ConnectorUtils.simulate(
+        this.syncService,
+        this.i18nService,
+        this.simSinceLast
+      );
+      const result = await this.simPromise;
+      this.simGroups = result.groups;
+      this.simUsers = result.users;
+      this.simEnabledUsers = result.enabledUsers;
+      this.simDisabledUsers = result.disabledUsers;
+      this.simDeletedUsers = result.deletedUsers;
+    } catch (e) {
+      this.simGroups = null;
+      this.simUsers = null;
     }
+  }
+
+  private async updateLastSync() {
+    this.lastGroupSync = await this.stateService.getLastGroupSync();
+    this.lastUserSync = await this.stateService.getLastUserSync();
+  }
 }

src/app/tabs/more.component.html

@@ -1,32 +1,38 @@
 <div class="row">
-    <div class="col-sm">
-        <div class="card">
-            <h3 class="card-header">{{'about' | i18n}}</h3>
-            <div class="card-body">
-                <p>
-                    {{'bitwardenDirectoryConnector' | i18n}}
-                    <br /> {{'version' | i18n : version}}
-                    <br /> &copy; Bitwarden Inc. LLC 2015-{{year}}
-                </p>
-                <button class="btn btn-primary" type="button" (click)="update()" [disabled]="checkingForUpdate">
-                    <i class="fa fa-download fa-fw" [hidden]="checkingForUpdate"></i>
-                    <i class="fa fa-spinner fa-fw fa-spin" [hidden]="!checkingForUpdate"></i>
-                    {{'checkForUpdates' | i18n}}
-                </button>
-            </div>
-        </div>
+  <div class="col-sm">
+    <div class="card">
+      <h3 class="card-header">{{ "about" | i18n }}</h3>
+      <div class="card-body">
+        <p>
+          {{ "bitwardenDirectoryConnector" | i18n }}
+          <br />
+          {{ "version" | i18n: version }} <br />
+          &copy; Bitwarden Inc. LLC 2015-{{ year }}
+        </p>
+        <button
+          class="btn btn-primary"
+          type="button"
+          (click)="update()"
+          [disabled]="checkingForUpdate"
+        >
+          <i class="bwi bwi-download bwi-fw" [hidden]="checkingForUpdate"></i>
+          <i class="bwi bwi-spinner bwi-fw bwi-spin" [hidden]="!checkingForUpdate"></i>
+          {{ "checkForUpdates" | i18n }}
+        </button>
+      </div>
     </div>
-    <div class="col-sm">
-        <div class="card">
-            <h3 class="card-header">{{'other' | i18n}}</h3>
-            <div class="card-body">
-                <button class="btn btn-primary" type="button" (click)="logOut()">
-                    {{'logOut' | i18n}}
-                </button>
-                <button class="btn btn-primary" type="button" (click)="clearCache()">
-                    {{'clearSyncCache' | i18n}}
-                </button>
-            </div>
-        </div>
+  </div>
+  <div class="col-sm">
+    <div class="card">
+      <h3 class="card-header">{{ "other" | i18n }}</h3>
+      <div class="card-body">
+        <button class="btn btn-primary" type="button" (click)="logOut()">
+          {{ "logOut" | i18n }}
+        </button>
+        <button class="btn btn-primary" type="button" (click)="clearCache()">
+          {{ "clearSyncCache" | i18n }}
+        </button>
+      </div>
     </div>
+  </div>
 </div>

src/app/tabs/more.component.ts

@@ -1,78 +1,77 @@
-import {
-    ChangeDetectorRef,
-    Component,
-    NgZone,
-    OnDestroy,
-    OnInit,
-} from '@angular/core';
+import { ChangeDetectorRef, Component, NgZone, OnInit } from "@angular/core";
 
-import { ToasterService } from 'angular2-toaster';
+import { BroadcasterService } from "jslib-common/abstractions/broadcaster.service";
+import { I18nService } from "jslib-common/abstractions/i18n.service";
+import { MessagingService } from "jslib-common/abstractions/messaging.service";
+import { PlatformUtilsService } from "jslib-common/abstractions/platformUtils.service";
 
-import { BroadcasterService } from 'jslib/angular/services/broadcaster.service';
+import { StateService } from "../../abstractions/state.service";
 
-import { I18nService } from 'jslib/abstractions/i18n.service';
-import { MessagingService } from 'jslib/abstractions/messaging.service';
-import { PlatformUtilsService } from 'jslib/abstractions/platformUtils.service';
-
-import { ConfigurationService } from '../../services/configuration.service';
-
-const BroadcasterSubscriptionId = 'MoreComponent';
+const BroadcasterSubscriptionId = "MoreComponent";
 
 @Component({
-    selector: 'app-more',
-    templateUrl: 'more.component.html',
+  selector: "app-more",
+  templateUrl: "more.component.html",
 })
 export class MoreComponent implements OnInit {
-    version: string;
-    year: string;
-    checkingForUpdate = false;
+  version: string;
+  year: string;
+  checkingForUpdate = false;
 
-    constructor(private platformUtilsService: PlatformUtilsService, private i18nService: I18nService,
-        private messagingService: MessagingService, private configurationService: ConfigurationService,
-        private toasterService: ToasterService, private broadcasterService: BroadcasterService,
-        private ngZone: NgZone, private changeDetectorRef: ChangeDetectorRef) { }
+  constructor(
+    private platformUtilsService: PlatformUtilsService,
+    private i18nService: I18nService,
+    private messagingService: MessagingService,
+    private broadcasterService: BroadcasterService,
+    private ngZone: NgZone,
+    private changeDetectorRef: ChangeDetectorRef,
+    private stateService: StateService
+  ) {}
 
-    async ngOnInit() {
-        this.broadcasterService.subscribe(BroadcasterSubscriptionId, async (message: any) => {
-            this.ngZone.run(async () => {
-                switch (message.command) {
-                    case 'checkingForUpdate':
-                        this.checkingForUpdate = true;
-                        break;
-                    case 'doneCheckingForUpdate':
-                        this.checkingForUpdate = false;
-                        break;
-                    default:
-                        break;
-                }
-
-                this.changeDetectorRef.detectChanges();
-            });
-        });
-
-        this.year = new Date().getFullYear().toString();
-        this.version = await this.platformUtilsService.getApplicationVersion();
-    }
-
-    ngOnDestroy() {
-        this.broadcasterService.unsubscribe(BroadcasterSubscriptionId);
-    }
-
-    update() {
-        this.messagingService.send('checkForUpdate');
-    }
-
-    async logOut() {
-        const confirmed = await this.platformUtilsService.showDialog(
-            this.i18nService.t('logOutConfirmation'), this.i18nService.t('logOut'),
-            this.i18nService.t('yes'), this.i18nService.t('cancel'));
-        if (confirmed) {
-            this.messagingService.send('logout');
+  async ngOnInit() {
+    this.broadcasterService.subscribe(BroadcasterSubscriptionId, async (message: any) => {
+      this.ngZone.run(async () => {
+        switch (message.command) {
+          case "checkingForUpdate":
+            this.checkingForUpdate = true;
+            break;
+          case "doneCheckingForUpdate":
+            this.checkingForUpdate = false;
+            break;
+          default:
+            break;
         }
-    }
 
-    async clearCache() {
-        await this.configurationService.clearStatefulSettings(true);
-        this.toasterService.popAsync('success', null, this.i18nService.t('syncCacheCleared'));
+        this.changeDetectorRef.detectChanges();
+      });
+    });
+
+    this.year = new Date().getFullYear().toString();
+    this.version = await this.platformUtilsService.getApplicationVersion();
+  }
+
+  ngOnDestroy() {
+    this.broadcasterService.unsubscribe(BroadcasterSubscriptionId);
+  }
+
+  update() {
+    this.messagingService.send("checkForUpdate");
+  }
+
+  async logOut() {
+    const confirmed = await this.platformUtilsService.showDialog(
+      this.i18nService.t("logOutConfirmation"),
+      this.i18nService.t("logOut"),
+      this.i18nService.t("yes"),
+      this.i18nService.t("cancel")
+    );
+    if (confirmed) {
+      this.messagingService.send("logout");
     }
+  }
+
+  async clearCache() {
+    await this.stateService.clearSyncSettings(true);
+    this.platformUtilsService.showToast("success", null, this.i18nService.t("syncCacheCleared"));
+  }
 }

src/app/tabs/settings.component.ts

@@ -1,141 +1,154 @@
-import {
-    ChangeDetectorRef,
-    Component,
-    NgZone,
-    OnDestroy,
-    OnInit,
-} from '@angular/core';
+import { ChangeDetectorRef, Component, NgZone, OnDestroy, OnInit } from "@angular/core";
 
-import { I18nService } from 'jslib/abstractions/i18n.service';
-import { StateService } from 'jslib/abstractions/state.service';
+import { I18nService } from "jslib-common/abstractions/i18n.service";
+import { LogService } from "jslib-common/abstractions/log.service";
 
-import { ProfileOrganizationResponse } from 'jslib/models/response/profileOrganizationResponse';
+import { DirectoryType } from "../../enums/directoryType";
 
-import { ConfigurationService } from '../../services/configuration.service';
+import { AzureConfiguration } from "../../models/azureConfiguration";
+import { GSuiteConfiguration } from "../../models/gsuiteConfiguration";
+import { LdapConfiguration } from "../../models/ldapConfiguration";
+import { OktaConfiguration } from "../../models/oktaConfiguration";
+import { OneLoginConfiguration } from "../../models/oneLoginConfiguration";
+import { SyncConfiguration } from "../../models/syncConfiguration";
 
-import { DirectoryType } from '../../enums/directoryType';
-
-import { AzureConfiguration } from '../../models/azureConfiguration';
-import { GSuiteConfiguration } from '../../models/gsuiteConfiguration';
-import { LdapConfiguration } from '../../models/ldapConfiguration';
-import { OktaConfiguration } from '../../models/oktaConfiguration';
-import { OneLoginConfiguration } from '../../models/oneLoginConfiguration';
-import { SyncConfiguration } from '../../models/syncConfiguration';
-
-import { ConnectorUtils } from '../../utils';
+import { StateService } from "../../abstractions/state.service";
+import { ConnectorUtils } from "../../utils";
 
 @Component({
-    selector: 'app-settings',
-    templateUrl: 'settings.component.html',
+  selector: "app-settings",
+  templateUrl: "settings.component.html",
 })
 export class SettingsComponent implements OnInit, OnDestroy {
-    directory: DirectoryType;
-    directoryType = DirectoryType;
-    ldap = new LdapConfiguration();
-    gsuite = new GSuiteConfiguration();
-    azure = new AzureConfiguration();
-    okta = new OktaConfiguration();
-    oneLogin = new OneLoginConfiguration();
-    sync = new SyncConfiguration();
-    organizationId: string;
-    directoryOptions: any[];
-    organizationOptions: any[];
+  directory: DirectoryType;
+  directoryType = DirectoryType;
+  ldap = new LdapConfiguration();
+  gsuite = new GSuiteConfiguration();
+  azure = new AzureConfiguration();
+  okta = new OktaConfiguration();
+  oneLogin = new OneLoginConfiguration();
+  sync = new SyncConfiguration();
+  directoryOptions: any[];
+  showLdapPassword: boolean = false;
+  showAzureKey: boolean = false;
+  showOktaKey: boolean = false;
+  showOneLoginSecret: boolean = false;
 
-    constructor(private i18nService: I18nService, private configurationService: ConfigurationService,
-        private changeDetectorRef: ChangeDetectorRef, private ngZone: NgZone,
-        private stateService: StateService) {
-        this.directoryOptions = [
-            { name: i18nService.t('select'), value: null },
-            { name: 'Active Directory / LDAP', value: DirectoryType.Ldap },
-            { name: 'Azure Active Directory', value: DirectoryType.AzureActiveDirectory },
-            { name: 'G Suite (Google)', value: DirectoryType.GSuite },
-            { name: 'Okta', value: DirectoryType.Okta },
-            { name: 'OneLogin', value: DirectoryType.OneLogin },
-        ];
+  constructor(
+    private i18nService: I18nService,
+    private changeDetectorRef: ChangeDetectorRef,
+    private ngZone: NgZone,
+    private logService: LogService,
+    private stateService: StateService
+  ) {
+    this.directoryOptions = [
+      { name: this.i18nService.t("select"), value: null },
+      { name: "Active Directory / LDAP", value: DirectoryType.Ldap },
+      { name: "Azure Active Directory", value: DirectoryType.AzureActiveDirectory },
+      { name: "G Suite (Google)", value: DirectoryType.GSuite },
+      { name: "Okta", value: DirectoryType.Okta },
+      { name: "OneLogin", value: DirectoryType.OneLogin },
+    ];
+  }
+
+  async ngOnInit() {
+    this.directory = await this.stateService.getDirectoryType();
+    this.ldap =
+      (await this.stateService.getDirectory<LdapConfiguration>(DirectoryType.Ldap)) || this.ldap;
+    this.gsuite =
+      (await this.stateService.getDirectory<GSuiteConfiguration>(DirectoryType.GSuite)) ||
+      this.gsuite;
+    this.azure =
+      (await this.stateService.getDirectory<AzureConfiguration>(
+        DirectoryType.AzureActiveDirectory
+      )) || this.azure;
+    this.okta =
+      (await this.stateService.getDirectory<OktaConfiguration>(DirectoryType.Okta)) || this.okta;
+    this.oneLogin =
+      (await this.stateService.getDirectory<OneLoginConfiguration>(DirectoryType.OneLogin)) ||
+      this.oneLogin;
+    this.sync = (await this.stateService.getSync()) || this.sync;
+  }
+
+  async ngOnDestroy() {
+    await this.submit();
+  }
+
+  async submit() {
+    ConnectorUtils.adjustConfigForSave(this.ldap, this.sync);
+    if (this.ldap != null && this.ldap.ad) {
+      this.ldap.pagedSearch = true;
+    }
+    await this.stateService.setDirectoryType(this.directory);
+    await this.stateService.setDirectory(DirectoryType.Ldap, this.ldap);
+    await this.stateService.setDirectory(DirectoryType.GSuite, this.gsuite);
+    await this.stateService.setDirectory(DirectoryType.AzureActiveDirectory, this.azure);
+    await this.stateService.setDirectory(DirectoryType.Okta, this.okta);
+    await this.stateService.setDirectory(DirectoryType.OneLogin, this.oneLogin);
+    await this.stateService.setSync(this.sync);
+  }
+
+  parseKeyFile() {
+    const filePicker = document.getElementById("keyFile") as HTMLInputElement;
+    if (filePicker.files == null || filePicker.files.length < 0) {
+      return;
     }
 
-    async ngOnInit() {
-        this.organizationOptions = [{ name: this.i18nService.t('select'), value: null }];
-        const orgs = await this.stateService.get<ProfileOrganizationResponse[]>('profileOrganizations');
-        if (orgs != null) {
-            for (const org of orgs) {
-                this.organizationOptions.push({ name: org.name, value: org.id });
-            }
+    const reader = new FileReader();
+    reader.readAsText(filePicker.files[0], "utf-8");
+    reader.onload = (evt) => {
+      this.ngZone.run(async () => {
+        try {
+          const result = JSON.parse((evt.target as FileReader).result as string);
+          if (result.client_email != null && result.private_key != null) {
+            this.gsuite.clientEmail = result.client_email;
+            this.gsuite.privateKey = result.private_key;
+          }
+        } catch (e) {
+          this.logService.error(e);
         }
+        this.changeDetectorRef.detectChanges();
+      });
 
-        this.organizationId = await this.configurationService.getOrganizationId();
-        this.directory = await this.configurationService.getDirectoryType();
-        this.ldap = (await this.configurationService.getDirectory<LdapConfiguration>(DirectoryType.Ldap)) ||
-            this.ldap;
-        this.gsuite = (await this.configurationService.getDirectory<GSuiteConfiguration>(DirectoryType.GSuite)) ||
-            this.gsuite;
-        this.azure = (await this.configurationService.getDirectory<AzureConfiguration>(
-            DirectoryType.AzureActiveDirectory)) || this.azure;
-        this.okta = (await this.configurationService.getDirectory<OktaConfiguration>(
-            DirectoryType.Okta)) || this.okta;
-        this.oneLogin = (await this.configurationService.getDirectory<OneLoginConfiguration>(
-            DirectoryType.OneLogin)) || this.oneLogin;
-        this.sync = (await this.configurationService.getSync()) || this.sync;
+      // reset file input
+      // ref: https://stackoverflow.com/a/20552042
+      filePicker.type = "";
+      filePicker.type = "file";
+      filePicker.value = "";
+    };
+  }
+
+  setSslPath(id: string) {
+    const filePicker = document.getElementById(id + "_file") as HTMLInputElement;
+    if (filePicker.files == null || filePicker.files.length < 0) {
+      return;
     }
 
-    async ngOnDestroy() {
-        await this.submit();
-    }
+    (this.ldap as any)[id] = filePicker.files[0].path;
+    // reset file input
+    // ref: https://stackoverflow.com/a/20552042
+    filePicker.type = "";
+    filePicker.type = "file";
+    filePicker.value = "";
+  }
 
-    async submit() {
-        ConnectorUtils.adjustConfigForSave(this.ldap, this.sync);
-        if (this.ldap != null && this.ldap.ad) {
-            this.ldap.pagedSearch = true;
-        }
-        await this.configurationService.saveOrganizationId(this.organizationId);
-        await this.configurationService.saveDirectoryType(this.directory);
-        await this.configurationService.saveDirectory(DirectoryType.Ldap, this.ldap);
-        await this.configurationService.saveDirectory(DirectoryType.GSuite, this.gsuite);
-        await this.configurationService.saveDirectory(DirectoryType.AzureActiveDirectory, this.azure);
-        await this.configurationService.saveDirectory(DirectoryType.Okta, this.okta);
-        await this.configurationService.saveDirectory(DirectoryType.OneLogin, this.oneLogin);
-        await this.configurationService.saveSync(this.sync);
-    }
+  toggleLdapPassword() {
+    this.showLdapPassword = !this.showLdapPassword;
+    document.getElementById("password").focus();
+  }
 
-    parseKeyFile() {
-        const filePicker = (document.getElementById('keyFile') as HTMLInputElement);
-        if (filePicker.files == null || filePicker.files.length < 0) {
-            return;
-        }
+  toggleAzureKey() {
+    this.showAzureKey = !this.showAzureKey;
+    document.getElementById("secretKey").focus();
+  }
 
-        const reader = new FileReader();
-        reader.readAsText(filePicker.files[0], 'utf-8');
-        reader.onload = evt => {
-            this.ngZone.run(async () => {
-                try {
-                    const result = JSON.parse((evt.target as FileReader).result as string);
-                    if (result.client_email != null && result.private_key != null) {
-                        this.gsuite.clientEmail = result.client_email;
-                        this.gsuite.privateKey = result.private_key;
-                    }
-                } catch { }
-                this.changeDetectorRef.detectChanges();
-            });
+  toggleOktaKey() {
+    this.showOktaKey = !this.showOktaKey;
+    document.getElementById("oktaToken").focus();
+  }
 
-            // reset file input
-            // ref: https://stackoverflow.com/a/20552042
-            filePicker.type = '';
-            filePicker.type = 'file';
-            filePicker.value = '';
-        };
-    }
-
-    setSslPath(id: string) {
-        const filePicker = (document.getElementById(id + '_file') as HTMLInputElement);
-        if (filePicker.files == null || filePicker.files.length < 0) {
-            return;
-        }
-
-        (this.ldap as any)[id] = filePicker.files[0].path;
-        // reset file input
-        // ref: https://stackoverflow.com/a/20552042
-        filePicker.type = '';
-        filePicker.type = 'file';
-        filePicker.value = '';
-    }
+  toggleOneLoginSecret() {
+    this.showOneLoginSecret = !this.showOneLoginSecret;
+    document.getElementById("oneLoginClientSecret").focus();
+  }
 }

src/app/tabs/tabs.component.html

@@ -1,23 +1,23 @@
 <div class="container-fluid">
-    <ul class="nav nav-tabs mb-3">
-        <li class="nav-item">
-            <a class="nav-link" routerLink="dashboard" routerLinkActive="active">
-                <i class="fa fa-dashboard"></i>
-                {{'dashboard' | i18n}}
-            </a>
-        </li>
-        <li class="nav-item">
-            <a class="nav-link" routerLink="settings" routerLinkActive="active">
-                <i class="fa fa-cogs"></i>
-                {{'settings' | i18n}}
-            </a>
-        </li>
-        <li class="nav-item">
-            <a class="nav-link" routerLink="more" routerLinkActive="active">
-                <i class="fa fa-sliders"></i>
-                {{'more' | i18n}}
-            </a>
-        </li>
-    </ul>
-    <router-outlet></router-outlet>
+  <ul class="nav nav-tabs mb-3">
+    <li class="nav-item">
+      <a class="nav-link" routerLink="dashboard" routerLinkActive="active">
+        <i class="bwi bwi-dashboard"></i>
+        {{ "dashboard" | i18n }}
+      </a>
+    </li>
+    <li class="nav-item">
+      <a class="nav-link" routerLink="settings" routerLinkActive="active">
+        <i class="bwi bwi-cogs"></i>
+        {{ "settings" | i18n }}
+      </a>
+    </li>
+    <li class="nav-item">
+      <a class="nav-link" routerLink="more" routerLinkActive="active">
+        <i class="bwi bwi-sliders"></i>
+        {{ "more" | i18n }}
+      </a>
+    </li>
+  </ul>
+  <router-outlet></router-outlet>
 </div>

src/app/tabs/tabs.component.ts

@@ -1,7 +1,7 @@
-import { Component } from '@angular/core';
+import { Component } from "@angular/core";
 
 @Component({
-    selector: 'app-tabs',
-    templateUrl: 'tabs.component.html',
+  selector: "app-tabs",
+  templateUrl: "tabs.component.html",
 })
-export class TabsComponent { }
+export class TabsComponent {}

src/bwdc.ts

@@ -1,141 +1,294 @@
-import * as fs from 'fs';
-import * as path from 'path';
+import * as fs from "fs";
+import * as path from "path";
 
-import { LogLevelType } from 'jslib/enums/logLevelType';
+import { LogLevelType } from "jslib-common/enums/logLevelType";
 
-import { AuthService } from 'jslib/services/auth.service';
+import { AuthService } from "./services/auth.service";
 
-import { ConfigurationService } from './services/configuration.service';
-import { I18nService } from './services/i18n.service';
-import { KeytarSecureStorageService } from './services/keytarSecureStorage.service';
-import { LowdbStorageService } from './services/lowdbStorage.service';
-import { SyncService } from './services/sync.service';
+import { I18nService } from "./services/i18n.service";
+import { KeytarSecureStorageService } from "./services/keytarSecureStorage.service";
+import { LowdbStorageService } from "./services/lowdbStorage.service";
+import { StateService } from "./services/state.service";
+import { StateMigrationService } from "./services/stateMigration.service";
+import { SyncService } from "./services/sync.service";
 
-import { CliPlatformUtilsService } from 'jslib/cli/services/cliPlatformUtils.service';
-import { ConsoleLogService } from 'jslib/cli/services/consoleLog.service';
+import { CliPlatformUtilsService } from "jslib-node/cli/services/cliPlatformUtils.service";
+import { ConsoleLogService } from "jslib-node/cli/services/consoleLog.service";
+import { NodeApiService } from "jslib-node/services/nodeApi.service";
+import { NodeCryptoFunctionService } from "jslib-node/services/nodeCryptoFunction.service";
 
-import { AppIdService } from 'jslib/services/appId.service';
-import { ConstantsService } from 'jslib/services/constants.service';
-import { ContainerService } from 'jslib/services/container.service';
-import { CryptoService } from 'jslib/services/crypto.service';
-import { EnvironmentService } from 'jslib/services/environment.service';
-import { NodeApiService } from 'jslib/services/nodeApi.service';
-import { NodeCryptoFunctionService } from 'jslib/services/nodeCryptoFunction.service';
-import { NoopMessagingService } from 'jslib/services/noopMessaging.service';
-import { PasswordGenerationService } from 'jslib/services/passwordGeneration.service';
-import { TokenService } from 'jslib/services/token.service';
-import { UserService } from 'jslib/services/user.service';
+import { AppIdService } from "jslib-common/services/appId.service";
+import { CipherService } from "jslib-common/services/cipher.service";
+import { CollectionService } from "jslib-common/services/collection.service";
+import { ContainerService } from "jslib-common/services/container.service";
+import { CryptoService } from "jslib-common/services/crypto.service";
+import { EnvironmentService } from "jslib-common/services/environment.service";
+import { FileUploadService } from "jslib-common/services/fileUpload.service";
+import { FolderService } from "jslib-common/services/folder.service";
+import { KeyConnectorService } from "jslib-common/services/keyConnector.service";
+import { NoopMessagingService } from "jslib-common/services/noopMessaging.service";
+import { OrganizationService } from "jslib-common/services/organization.service";
+import { PasswordGenerationService } from "jslib-common/services/passwordGeneration.service";
+import { PolicyService } from "jslib-common/services/policy.service";
+import { ProviderService } from "jslib-common/services/provider.service";
+import { SearchService } from "jslib-common/services/search.service";
+import { SendService } from "jslib-common/services/send.service";
+import { SettingsService } from "jslib-common/services/settings.service";
+import { TokenService } from "jslib-common/services/token.service";
 
-import { StorageService as StorageServiceAbstraction } from 'jslib/abstractions/storage.service';
+import { StorageService as StorageServiceAbstraction } from "jslib-common/abstractions/storage.service";
 
-import { Program } from './program';
+import { Program } from "./program";
+
+import { Account } from "./models/account";
+
+import { GlobalStateFactory } from "jslib-common/factories/globalStateFactory";
+import { StateFactory } from "jslib-common/factories/stateFactory";
+
+import { GlobalState } from "jslib-common/models/domain/globalState";
 
 // tslint:disable-next-line
-const packageJson = require('./package.json');
+const packageJson = require("./package.json");
 
+export let searchService: SearchService = null;
 export class Main {
-    dataFilePath: string;
-    logService: ConsoleLogService;
-    messagingService: NoopMessagingService;
-    storageService: LowdbStorageService;
-    secureStorageService: StorageServiceAbstraction;
-    i18nService: I18nService;
-    platformUtilsService: CliPlatformUtilsService;
-    constantsService: ConstantsService;
-    cryptoService: CryptoService;
-    tokenService: TokenService;
-    appIdService: AppIdService;
-    apiService: NodeApiService;
-    environmentService: EnvironmentService;
-    userService: UserService;
-    containerService: ContainerService;
-    cryptoFunctionService: NodeCryptoFunctionService;
-    authService: AuthService;
-    configurationService: ConfigurationService;
-    syncService: SyncService;
-    passwordGenerationService: PasswordGenerationService;
-    program: Program;
+  dataFilePath: string;
+  logService: ConsoleLogService;
+  messagingService: NoopMessagingService;
+  storageService: LowdbStorageService;
+  secureStorageService: StorageServiceAbstraction;
+  i18nService: I18nService;
+  platformUtilsService: CliPlatformUtilsService;
+  cryptoService: CryptoService;
+  tokenService: TokenService;
+  appIdService: AppIdService;
+  apiService: NodeApiService;
+  environmentService: EnvironmentService;
+  containerService: ContainerService;
+  cryptoFunctionService: NodeCryptoFunctionService;
+  authService: AuthService;
+  collectionService: CollectionService;
+  cipherService: CipherService;
+  fileUploadService: FileUploadService;
+  folderService: FolderService;
+  searchService: SearchService;
+  sendService: SendService;
+  settingsService: SettingsService;
+  syncService: SyncService;
+  passwordGenerationService: PasswordGenerationService;
+  policyService: PolicyService;
+  keyConnectorService: KeyConnectorService;
+  program: Program;
+  stateService: StateService;
+  stateMigrationService: StateMigrationService;
+  organizationService: OrganizationService;
+  providerService: ProviderService;
 
-    constructor() {
-        const applicationName = 'Bitwarden Directory Connector';
-        if (process.env.BITWARDENCLI_CONNECTOR_APPDATA_DIR) {
-            this.dataFilePath = path.resolve(process.env.BITWARDENCLI_CONNECTOR_APPDATA_DIR);
-        } else if (process.env.BITWARDEN_CONNECTOR_APPDATA_DIR) {
-            this.dataFilePath = path.resolve(process.env.BITWARDEN_CONNECTOR_APPDATA_DIR);
-        } else if (fs.existsSync(path.join(__dirname, 'bitwarden-connector-appdata'))) {
-            this.dataFilePath = path.join(__dirname, 'bitwarden-connector-appdata');
-        } else if (process.platform === 'darwin') {
-            this.dataFilePath = path.join(process.env.HOME, 'Library/Application Support/' + applicationName);
-        } else if (process.platform === 'win32') {
-            this.dataFilePath = path.join(process.env.APPDATA, applicationName);
-        } else if (process.env.XDG_CONFIG_HOME) {
-            this.dataFilePath = path.join(process.env.XDG_CONFIG_HOME, applicationName);
-        } else {
-            this.dataFilePath = path.join(process.env.HOME, '.config/' + applicationName);
-        }
-
-        const plaintextSecrets = process.env.BITWARDENCLI_CONNECTOR_PLAINTEXT_SECRETS === 'true';
-        this.i18nService = new I18nService('en', './locales');
-        this.platformUtilsService = new CliPlatformUtilsService('connector', packageJson);
-        this.logService = new ConsoleLogService(this.platformUtilsService.isDev(),
-            level => process.env.BITWARDENCLI_CONNECTOR_DEBUG !== 'true' && level <= LogLevelType.Info);
-        this.cryptoFunctionService = new NodeCryptoFunctionService();
-        this.storageService = new LowdbStorageService(this.logService, null, this.dataFilePath, false, true);
-        this.secureStorageService = plaintextSecrets ?
-            this.storageService : new KeytarSecureStorageService(applicationName);
-        this.cryptoService = new CryptoService(this.storageService, this.secureStorageService,
-            this.cryptoFunctionService, this.platformUtilsService, this.logService);
-        this.appIdService = new AppIdService(this.storageService);
-        this.tokenService = new TokenService(this.storageService);
-        this.messagingService = new NoopMessagingService();
-        this.apiService = new NodeApiService(this.tokenService, this.platformUtilsService,
-            async (expired: boolean) => await this.logout());
-        this.environmentService = new EnvironmentService(this.apiService, this.storageService, null);
-        this.userService = new UserService(this.tokenService, this.storageService);
-        this.containerService = new ContainerService(this.cryptoService);
-        this.authService = new AuthService(this.cryptoService, this.apiService, this.userService, this.tokenService,
-            this.appIdService, this.i18nService, this.platformUtilsService, this.messagingService, null,
-            this.logService, false);
-        this.configurationService = new ConfigurationService(this.storageService, this.secureStorageService,
-            process.env.BITWARDENCLI_CONNECTOR_PLAINTEXT_SECRETS !== 'true');
-        this.syncService = new SyncService(this.configurationService, this.logService, this.cryptoFunctionService,
-            this.apiService, this.messagingService, this.i18nService);
-        this.passwordGenerationService = new PasswordGenerationService(this.cryptoService, this.storageService, null);
-        this.program = new Program(this);
+  constructor() {
+    const applicationName = "Bitwarden Directory Connector";
+    if (process.env.BITWARDENCLI_CONNECTOR_APPDATA_DIR) {
+      this.dataFilePath = path.resolve(process.env.BITWARDENCLI_CONNECTOR_APPDATA_DIR);
+    } else if (process.env.BITWARDEN_CONNECTOR_APPDATA_DIR) {
+      this.dataFilePath = path.resolve(process.env.BITWARDEN_CONNECTOR_APPDATA_DIR);
+    } else if (fs.existsSync(path.join(__dirname, "bitwarden-connector-appdata"))) {
+      this.dataFilePath = path.join(__dirname, "bitwarden-connector-appdata");
+    } else if (process.platform === "darwin") {
+      this.dataFilePath = path.join(
+        process.env.HOME,
+        "Library/Application Support/" + applicationName
+      );
+    } else if (process.platform === "win32") {
+      this.dataFilePath = path.join(process.env.APPDATA, applicationName);
+    } else if (process.env.XDG_CONFIG_HOME) {
+      this.dataFilePath = path.join(process.env.XDG_CONFIG_HOME, applicationName);
+    } else {
+      this.dataFilePath = path.join(process.env.HOME, ".config/" + applicationName);
     }
 
-    async run() {
-        await this.init();
-        this.program.run();
-    }
+    const plaintextSecrets = process.env.BITWARDENCLI_CONNECTOR_PLAINTEXT_SECRETS === "true";
+    this.i18nService = new I18nService("en", "./locales");
+    this.platformUtilsService = new CliPlatformUtilsService("connector", packageJson);
+    this.logService = new ConsoleLogService(
+      this.platformUtilsService.isDev(),
+      (level) => process.env.BITWARDENCLI_CONNECTOR_DEBUG !== "true" && level <= LogLevelType.Info
+    );
+    this.cryptoFunctionService = new NodeCryptoFunctionService();
+    this.storageService = new LowdbStorageService(
+      this.logService,
+      null,
+      this.dataFilePath,
+      false,
+      true
+    );
+    this.secureStorageService = plaintextSecrets
+      ? this.storageService
+      : new KeytarSecureStorageService(applicationName);
 
-    async logout() {
-        await Promise.all([
-            this.tokenService.clearToken(),
-            this.userService.clear(),
-        ]);
-    }
+    this.stateMigrationService = new StateMigrationService(
+      this.storageService,
+      this.secureStorageService,
+      new StateFactory(GlobalState, Account)
+    );
 
-    private async init() {
-        await this.storageService.init();
-        this.containerService.attachToWindow(global);
-        await this.environmentService.setUrlsFromStorage();
-        // Dev Server URLs. Comment out the line above.
-        // this.apiService.setUrls({
-        //     base: null,
-        //     api: 'http://localhost:4000',
-        //     identity: 'http://localhost:33656',
-        // });
-        const locale = await this.storageService.get<string>(ConstantsService.localeKey);
-        await this.i18nService.init(locale);
-        this.authService.init();
+    this.stateService = new StateService(
+      this.storageService,
+      this.secureStorageService,
+      this.logService,
+      this.stateMigrationService,
+      process.env.BITWARDENCLI_CONNECTOR_PLAINTEXT_SECRETS !== "true",
+      new StateFactory(GlobalState, Account)
+    );
 
-        const installedVersion = await this.storageService.get<string>(ConstantsService.installedVersionKey);
-        const currentVersion = await this.platformUtilsService.getApplicationVersion();
-        if (installedVersion == null || installedVersion !== currentVersion) {
-            await this.storageService.save(ConstantsService.installedVersionKey, currentVersion);
-        }
+    this.cryptoService = new CryptoService(
+      this.cryptoFunctionService,
+      this.platformUtilsService,
+      this.logService,
+      this.stateService
+    );
+
+    this.appIdService = new AppIdService(this.storageService);
+    this.tokenService = new TokenService(this.stateService);
+    this.messagingService = new NoopMessagingService();
+    this.environmentService = new EnvironmentService(this.stateService);
+    this.apiService = new NodeApiService(
+      this.tokenService,
+      this.platformUtilsService,
+      this.environmentService,
+      async (expired: boolean) => await this.logout(),
+      "Bitwarden_DC/" +
+        this.platformUtilsService.getApplicationVersion() +
+        " (" +
+        this.platformUtilsService.getDeviceString().toUpperCase() +
+        ")",
+      (clientId, clientSecret) => this.authService.logInApiKey(clientId, clientSecret)
+    );
+    this.containerService = new ContainerService(this.cryptoService);
+
+    this.organizationService = new OrganizationService(this.stateService);
+
+    this.keyConnectorService = new KeyConnectorService(
+      this.stateService,
+      this.cryptoService,
+      this.apiService,
+      this.tokenService,
+      this.logService,
+      this.organizationService
+    );
+
+    this.authService = new AuthService(
+      this.cryptoService,
+      this.apiService,
+      this.tokenService,
+      this.appIdService,
+      this.i18nService,
+      this.platformUtilsService,
+      this.messagingService,
+      null,
+      this.logService,
+      this.cryptoFunctionService,
+      this.environmentService,
+      this.keyConnectorService,
+      this.stateService
+    );
+
+    this.syncService = new SyncService(
+      this.logService,
+      this.cryptoFunctionService,
+      this.apiService,
+      this.messagingService,
+      this.i18nService,
+      this.environmentService,
+      this.stateService
+    );
+
+    this.policyService = new PolicyService(
+      this.stateService,
+      this.organizationService,
+      this.apiService
+    );
+
+    this.passwordGenerationService = new PasswordGenerationService(
+      this.cryptoService,
+      this.policyService,
+      this.stateService
+    );
+
+    this.settingsService = new SettingsService(this.stateService);
+
+    this.fileUploadService = new FileUploadService(this.logService, this.apiService);
+
+    this.cipherService = new CipherService(
+      this.cryptoService,
+      this.settingsService,
+      this.apiService,
+      this.fileUploadService,
+      this.i18nService,
+      () => searchService,
+      this.logService,
+      this.stateService
+    );
+
+    this.searchService = new SearchService(this.cipherService, this.logService, this.i18nService);
+
+    this.folderService = new FolderService(
+      this.cryptoService,
+      this.apiService,
+      this.i18nService,
+      this.cipherService,
+      this.stateService
+    );
+
+    this.collectionService = new CollectionService(
+      this.cryptoService,
+      this.i18nService,
+      this.stateService
+    );
+
+    this.sendService = new SendService(
+      this.cryptoService,
+      this.apiService,
+      this.fileUploadService,
+      this.i18nService,
+      this.cryptoFunctionService,
+      this.stateService
+    );
+
+    this.providerService = new ProviderService(this.stateService);
+
+    this.program = new Program(this);
+  }
+
+  async run() {
+    await this.init();
+    this.program.run();
+  }
+
+  async logout() {
+    await this.tokenService.clearToken();
+    await this.stateService.clean();
+  }
+
+  private async init() {
+    await this.storageService.init();
+    await this.stateService.init();
+    this.containerService.attachToWindow(global);
+    await this.environmentService.setUrlsFromStorage();
+    // Dev Server URLs. Comment out the line above.
+    // this.apiService.setUrls({
+    //     base: null,
+    //     api: 'http://localhost:4000',
+    //     identity: 'http://localhost:33656',
+    // });
+    const locale = await this.stateService.getLocale();
+    await this.i18nService.init(locale);
+    this.authService.init();
+
+    const installedVersion = await this.stateService.getInstalledVersion();
+    const currentVersion = await this.platformUtilsService.getApplicationVersion();
+    if (installedVersion == null || installedVersion !== currentVersion) {
+      await this.stateService.setInstalledVersion(currentVersion);
     }
+  }
 }
 
 const main = new Main();

src/commands/clearCache.command.ts

@@ -1,22 +1,21 @@
-import * as program from 'commander';
+import * as program from "commander";
 
-import { I18nService } from 'jslib/abstractions/i18n.service';
+import { I18nService } from "jslib-common/abstractions/i18n.service";
 
-import { ConfigurationService } from '../services/configuration.service';
-
-import { Response } from 'jslib/cli/models/response';
-import { MessageResponse } from 'jslib/cli/models/response/messageResponse';
+import { Response } from "jslib-node/cli/models/response";
+import { MessageResponse } from "jslib-node/cli/models/response/messageResponse";
+import { StateService } from "../abstractions/state.service";
 
 export class ClearCacheCommand {
-    constructor(private configurationService: ConfigurationService, private i18nService: I18nService) { }
+  constructor(private i18nService: I18nService, private stateService: StateService) {}
 
-    async run(cmd: program.OptionValues): Promise<Response> {
-        try {
-            await this.configurationService.clearStatefulSettings(true);
-            const res = new MessageResponse(this.i18nService.t('syncCacheCleared'), null);
-            return Response.success(res);
-        } catch (e) {
-            return Response.error(e);
-        }
+  async run(cmd: program.OptionValues): Promise<Response> {
+    try {
+      await this.stateService.clearSyncSettings(true);
+      const res = new MessageResponse(this.i18nService.t("syncCacheCleared"), null);
+      return Response.success(res);
+    } catch (e) {
+      return Response.error(e);
     }
+  }
 }

src/commands/config.command.ts

@@ -1,150 +1,157 @@
-import * as program from 'commander';
+import * as program from "commander";
 
-import { EnvironmentService } from 'jslib/abstractions/environment.service';
-import { I18nService } from 'jslib/abstractions/i18n.service';
+import { EnvironmentService } from "jslib-common/abstractions/environment.service";
+import { I18nService } from "jslib-common/abstractions/i18n.service";
 
-import { ConfigurationService } from '../services/configuration.service';
+import { StateService } from "../abstractions/state.service";
 
-import { DirectoryType } from '../enums/directoryType';
+import { DirectoryType } from "../enums/directoryType";
 
-import { Response } from 'jslib/cli/models/response';
-import { MessageResponse } from 'jslib/cli/models/response/messageResponse';
+import { Response } from "jslib-node/cli/models/response";
+import { MessageResponse } from "jslib-node/cli/models/response/messageResponse";
 
-import { AzureConfiguration } from '../models/azureConfiguration';
-import { GSuiteConfiguration } from '../models/gsuiteConfiguration';
-import { LdapConfiguration } from '../models/ldapConfiguration';
-import { OktaConfiguration } from '../models/oktaConfiguration';
-import { OneLoginConfiguration } from '../models/oneLoginConfiguration';
-import { SyncConfiguration } from '../models/syncConfiguration';
+import { AzureConfiguration } from "../models/azureConfiguration";
+import { GSuiteConfiguration } from "../models/gsuiteConfiguration";
+import { LdapConfiguration } from "../models/ldapConfiguration";
+import { OktaConfiguration } from "../models/oktaConfiguration";
+import { OneLoginConfiguration } from "../models/oneLoginConfiguration";
+import { SyncConfiguration } from "../models/syncConfiguration";
 
-import { ConnectorUtils } from '../utils';
+import { ConnectorUtils } from "../utils";
 
-import { NodeUtils } from 'jslib/misc/nodeUtils';
+import { NodeUtils } from "jslib-common/misc/nodeUtils";
 
 export class ConfigCommand {
-    private directory: DirectoryType;
-    private ldap = new LdapConfiguration();
-    private gsuite = new GSuiteConfiguration();
-    private azure = new AzureConfiguration();
-    private okta = new OktaConfiguration();
-    private oneLogin = new OneLoginConfiguration();
-    private sync = new SyncConfiguration();
+  private directory: DirectoryType;
+  private ldap = new LdapConfiguration();
+  private gsuite = new GSuiteConfiguration();
+  private azure = new AzureConfiguration();
+  private okta = new OktaConfiguration();
+  private oneLogin = new OneLoginConfiguration();
+  private sync = new SyncConfiguration();
 
-    constructor(private environmentService: EnvironmentService, private i18nService: I18nService,
-        private configurationService: ConfigurationService) { }
+  constructor(
+    private environmentService: EnvironmentService,
+    private i18nService: I18nService,
+    private stateService: StateService
+  ) {}
 
-    async run(setting: string, value: string, options: program.OptionValues): Promise<Response> {
-        setting = setting.toLowerCase();
-        if (value == null || value === '') {
-            if (options.secretfile) {
-                value = await NodeUtils.readFirstLine(options.secretfile);
-            } else if (options.secretenv && process.env[options.secretenv]) {
-                value = process.env[options.secretenv];
-            }
-        }
-        try {
-            switch (setting) {
-                case 'server':
-                    await this.setServer(value);
-                    break;
-                case 'directory':
-                    await this.setDirectory(value);
-                    break;
-                case 'ldap.password':
-                    await this.setLdapPassword(value);
-                    break;
-                case 'gsuite.key':
-                    await this.setGSuiteKey(value);
-                    break;
-                case 'azure.key':
-                    await this.setAzureKey(value);
-                    break;
-                case 'okta.token':
-                    await this.setOktaToken(value);
-                    break;
-                case 'onelogin.secret':
-                    await this.setOneLoginSecret(value);
-                    break;
-                default:
-                    return Response.badRequest('Unknown setting.');
-            }
-        } catch (e) {
-            return Response.error(e);
-        }
-        const res = new MessageResponse(this.i18nService.t('savedSetting', setting), null);
-        return Response.success(res);
+  async run(setting: string, value: string, options: program.OptionValues): Promise<Response> {
+    setting = setting.toLowerCase();
+    if (value == null || value === "") {
+      if (options.secretfile) {
+        value = await NodeUtils.readFirstLine(options.secretfile);
+      } else if (options.secretenv && process.env[options.secretenv]) {
+        value = process.env[options.secretenv];
+      }
     }
-
-    private async setServer(url: string) {
-        url = (url === 'null' || url === 'bitwarden.com' || url === 'https://bitwarden.com' ? null : url);
-        await this.environmentService.setUrls({
-            base: url,
-        });
+    try {
+      switch (setting) {
+        case "server":
+          await this.setServer(value);
+          break;
+        case "directory":
+          await this.setDirectory(value);
+          break;
+        case "ldap.password":
+          await this.setLdapPassword(value);
+          break;
+        case "gsuite.key":
+          await this.setGSuiteKey(value);
+          break;
+        case "azure.key":
+          await this.setAzureKey(value);
+          break;
+        case "okta.token":
+          await this.setOktaToken(value);
+          break;
+        case "onelogin.secret":
+          await this.setOneLoginSecret(value);
+          break;
+        default:
+          return Response.badRequest("Unknown setting.");
+      }
+    } catch (e) {
+      return Response.error(e);
     }
+    const res = new MessageResponse(this.i18nService.t("savedSetting", setting), null);
+    return Response.success(res);
+  }
 
-    private async setDirectory(type: string) {
-        const dir = parseInt(type, null);
-        if (dir < DirectoryType.Ldap || dir > DirectoryType.OneLogin) {
-            throw new Error('Invalid directory type value.');
-        }
-        await this.loadConfig();
-        this.directory = dir;
-        await this.saveConfig();
-    }
+  private async setServer(url: string) {
+    url = url === "null" || url === "bitwarden.com" || url === "https://bitwarden.com" ? null : url;
+    await this.environmentService.setUrls({
+      base: url,
+    });
+  }
 
-    private async setLdapPassword(password: string) {
-        await this.loadConfig();
-        this.ldap.password = password;
-        await this.saveConfig();
+  private async setDirectory(type: string) {
+    const dir = parseInt(type, null);
+    if (dir < DirectoryType.Ldap || dir > DirectoryType.OneLogin) {
+      throw new Error("Invalid directory type value.");
     }
+    await this.loadConfig();
+    this.directory = dir;
+    await this.saveConfig();
+  }
 
-    private async setGSuiteKey(key: string) {
-        await this.loadConfig();
-        this.gsuite.privateKey = key != null ? key.trimLeft() : null;
-        await this.saveConfig();
-    }
+  private async setLdapPassword(password: string) {
+    await this.loadConfig();
+    this.ldap.password = password;
+    await this.saveConfig();
+  }
 
-    private async setAzureKey(key: string) {
-        await this.loadConfig();
-        this.azure.key = key;
-        await this.saveConfig();
-    }
+  private async setGSuiteKey(key: string) {
+    await this.loadConfig();
+    this.gsuite.privateKey = key != null ? key.trimLeft() : null;
+    await this.saveConfig();
+  }
 
-    private async setOktaToken(token: string) {
-        await this.loadConfig();
-        this.okta.token = token;
-        await this.saveConfig();
-    }
+  private async setAzureKey(key: string) {
+    await this.loadConfig();
+    this.azure.key = key;
+    await this.saveConfig();
+  }
 
-    private async setOneLoginSecret(secret: string) {
-        await this.loadConfig();
-        this.oneLogin.clientSecret = secret;
-        await this.saveConfig();
-    }
+  private async setOktaToken(token: string) {
+    await this.loadConfig();
+    this.okta.token = token;
+    await this.saveConfig();
+  }
 
-    private async loadConfig() {
-        this.directory = await this.configurationService.getDirectoryType();
-        this.ldap = (await this.configurationService.getDirectory<LdapConfiguration>(DirectoryType.Ldap)) ||
-            this.ldap;
-        this.gsuite = (await this.configurationService.getDirectory<GSuiteConfiguration>(DirectoryType.GSuite)) ||
-            this.gsuite;
-        this.azure = (await this.configurationService.getDirectory<AzureConfiguration>(
-            DirectoryType.AzureActiveDirectory)) || this.azure;
-        this.okta = (await this.configurationService.getDirectory<OktaConfiguration>(
-            DirectoryType.Okta)) || this.okta;
-        this.oneLogin = (await this.configurationService.getDirectory<OneLoginConfiguration>(
-            DirectoryType.OneLogin)) || this.oneLogin;
-        this.sync = (await this.configurationService.getSync()) || this.sync;
-    }
+  private async setOneLoginSecret(secret: string) {
+    await this.loadConfig();
+    this.oneLogin.clientSecret = secret;
+    await this.saveConfig();
+  }
 
-    private async saveConfig() {
-        ConnectorUtils.adjustConfigForSave(this.ldap, this.sync);
-        await this.configurationService.saveDirectoryType(this.directory);
-        await this.configurationService.saveDirectory(DirectoryType.Ldap, this.ldap);
-        await this.configurationService.saveDirectory(DirectoryType.GSuite, this.gsuite);
-        await this.configurationService.saveDirectory(DirectoryType.AzureActiveDirectory, this.azure);
-        await this.configurationService.saveDirectory(DirectoryType.Okta, this.okta);
-        await this.configurationService.saveDirectory(DirectoryType.OneLogin, this.oneLogin);
-        await this.configurationService.saveSync(this.sync);
-    }
+  private async loadConfig() {
+    this.directory = await this.stateService.getDirectoryType();
+    this.ldap =
+      (await this.stateService.getDirectory<LdapConfiguration>(DirectoryType.Ldap)) || this.ldap;
+    this.gsuite =
+      (await this.stateService.getDirectory<GSuiteConfiguration>(DirectoryType.GSuite)) ||
+      this.gsuite;
+    this.azure =
+      (await this.stateService.getDirectory<AzureConfiguration>(
+        DirectoryType.AzureActiveDirectory
+      )) || this.azure;
+    this.okta =
+      (await this.stateService.getDirectory<OktaConfiguration>(DirectoryType.Okta)) || this.okta;
+    this.oneLogin =
+      (await this.stateService.getDirectory<OneLoginConfiguration>(DirectoryType.OneLogin)) ||
+      this.oneLogin;
+    this.sync = (await this.stateService.getSync()) || this.sync;
+  }
+
+  private async saveConfig() {
+    ConnectorUtils.adjustConfigForSave(this.ldap, this.sync);
+    await this.stateService.setDirectoryType(this.directory);
+    await this.stateService.setDirectory(DirectoryType.Ldap, this.ldap);
+    await this.stateService.setDirectory(DirectoryType.GSuite, this.gsuite);
+    await this.stateService.setDirectory(DirectoryType.AzureActiveDirectory, this.azure);
+    await this.stateService.setDirectory(DirectoryType.Okta, this.okta);
+    await this.stateService.setDirectory(DirectoryType.OneLogin, this.oneLogin);
+    await this.stateService.setSync(this.sync);
+  }
 }

src/commands/lastSync.command.ts

@@ -1,29 +1,31 @@
-import * as program from 'commander';
+import * as program from "commander";
 
-import { ConfigurationService } from '../services/configuration.service';
+import { StateService } from "../abstractions/state.service";
 
-import { Response } from 'jslib/cli/models/response';
-import { StringResponse } from 'jslib/cli/models/response/stringResponse';
+import { Response } from "jslib-node/cli/models/response";
+import { StringResponse } from "jslib-node/cli/models/response/stringResponse";
 
 export class LastSyncCommand {
-    constructor(private configurationService: ConfigurationService) { }
+  constructor(private stateService: StateService) {}
 
-    async run(object: string): Promise<Response> {
-        try {
-            switch (object.toLowerCase()) {
-                case 'groups':
-                    const groupsDate = await this.configurationService.getLastGroupSyncDate();
-                    const groupsRes = new StringResponse(groupsDate == null ? null : groupsDate.toISOString());
-                    return Response.success(groupsRes);
-                case 'users':
-                    const usersDate = await this.configurationService.getLastUserSyncDate();
-                    const usersRes = new StringResponse(usersDate == null ? null : usersDate.toISOString());
-                    return Response.success(usersRes);
-                default:
-                    return Response.badRequest('Unknown object.');
-            }
-        } catch (e) {
-            return Response.error(e);
-        }
+  async run(object: string): Promise<Response> {
+    try {
+      switch (object.toLowerCase()) {
+        case "groups":
+          const groupsDate = await this.stateService.getLastGroupSync();
+          const groupsRes = new StringResponse(
+            groupsDate == null ? null : groupsDate.toISOString()
+          );
+          return Response.success(groupsRes);
+        case "users":
+          const usersDate = await this.stateService.getLastUserSync();
+          const usersRes = new StringResponse(usersDate == null ? null : usersDate.toISOString());
+          return Response.success(usersRes);
+        default:
+          return Response.badRequest("Unknown object.");
+      }
+    } catch (e) {
+      return Response.error(e);
     }
+  }
 }

src/commands/sync.command.ts

@@ -1,25 +1,25 @@
-import * as program from 'commander';
+import { I18nService } from "jslib-common/abstractions/i18n.service";
 
-import { I18nService } from 'jslib/abstractions/i18n.service';
+import { SyncService } from "../services/sync.service";
 
-import { SyncService } from '../services/sync.service';
-
-import { Response } from 'jslib/cli/models/response';
-import { MessageResponse } from 'jslib/cli/models/response/messageResponse';
+import { Response } from "jslib-node/cli/models/response";
+import { MessageResponse } from "jslib-node/cli/models/response/messageResponse";
 
 export class SyncCommand {
-    constructor(private syncService: SyncService, private i18nService: I18nService) { }
+  constructor(private syncService: SyncService, private i18nService: I18nService) {}
 
-    async run(): Promise<Response> {
-        try {
-            const result = await this.syncService.sync(false, false);
-            const groupCount = result[0] != null ? result[0].length : 0;
-            const userCount = result[1] != null ? result[1].length : 0;
-            const res = new MessageResponse(this.i18nService.t('syncingComplete'),
-                this.i18nService.t('syncCounts', groupCount.toString(), userCount.toString()));
-            return Response.success(res);
-        } catch (e) {
-            return Response.error(e);
-        }
+  async run(): Promise<Response> {
+    try {
+      const result = await this.syncService.sync(false, false);
+      const groupCount = result[0] != null ? result[0].length : 0;
+      const userCount = result[1] != null ? result[1].length : 0;
+      const res = new MessageResponse(
+        this.i18nService.t("syncingComplete"),
+        this.i18nService.t("syncCounts", groupCount.toString(), userCount.toString())
+      );
+      return Response.success(res);
+    } catch (e) {
+      return Response.error(e);
     }
+  }
 }

src/commands/test.command.ts

@@ -1,24 +1,28 @@
-import * as program from 'commander';
+import * as program from "commander";
 
-import { I18nService } from 'jslib/abstractions/i18n.service';
+import { I18nService } from "jslib-common/abstractions/i18n.service";
 
-import { SyncService } from '../services/sync.service';
+import { SyncService } from "../services/sync.service";
 
-import { ConnectorUtils } from '../utils';
+import { ConnectorUtils } from "../utils";
 
-import { Response } from 'jslib/cli/models/response';
-import { TestResponse } from '../models/response/testResponse';
+import { Response } from "jslib-node/cli/models/response";
+import { TestResponse } from "../models/response/testResponse";
 
 export class TestCommand {
-    constructor(private syncService: SyncService, private i18nService: I18nService) { }
+  constructor(private syncService: SyncService, private i18nService: I18nService) {}
 
-    async run(cmd: program.OptionValues): Promise<Response> {
-        try {
-            const result = await ConnectorUtils.simulate(this.syncService, this.i18nService, cmd.last || false);
-            const res = new TestResponse(result);
-            return Response.success(res);
-        } catch (e) {
-            return Response.error(e);
-        }
+  async run(cmd: program.OptionValues): Promise<Response> {
+    try {
+      const result = await ConnectorUtils.simulate(
+        this.syncService,
+        this.i18nService,
+        cmd.last || false
+      );
+      const res = new TestResponse(result);
+      return Response.success(res);
+    } catch (e) {
+      return Response.error(e);
     }
+  }
 }

src/enums/directoryType.ts

@@ -1,7 +1,7 @@
 export enum DirectoryType {
-    Ldap = 0,
-    AzureActiveDirectory = 1,
-    GSuite = 2,
-    Okta = 3,
-    OneLogin = 4,
+  Ldap = 0,
+  AzureActiveDirectory = 1,
+  GSuite = 2,
+  Okta = 3,
+  OneLogin = 4,
 }

src/global.d.ts

@@ -1,3 +1,3 @@
 declare function escape(s: string): string;
 declare function unescape(s: string): string;
-declare module 'duo_web_sdk';
+declare module "duo_web_sdk";

src/index.html

@@ -1,16 +1,19 @@
 <!DOCTYPE html>
 <html>
-<head>
-    <meta charset="UTF-8">
-    <meta http-equiv="Content-Security-Policy" content="default-src 'self'; style-src 'self' 'unsafe-inline';
-        img-src 'self' data: *; child-src *; frame-src *; connect-src *;">
-    <meta name="viewport" content="width=device-width, initial-scale=1">
+  <head>
+    <meta charset="UTF-8" />
+    <meta
+      http-equiv="Content-Security-Policy"
+      content="default-src 'self'; style-src 'self' 'unsafe-inline';
+        img-src 'self' data: *; child-src *; frame-src *; connect-src *;"
+    />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
     <title>Bitwarden Directory Connector</title>
-    <base href="">
-</head>
-<body>
+    <base href="" />
+  </head>
+  <body>
     <app-root>
-        <div id="loading"><i class="fa fa-spinner fa-spin fa-3x"></i></div>
+      <div id="loading"><i class="bwi bwi-spinner bwi-spin bwi-3x"></i></div>
     </app-root>
-</body>
+  </body>
 </html>

src/locales/en/messages.json

@@ -20,12 +20,30 @@
     "emailRequired": {
         "message": "Email address is required."
     },
+    "clientIdRequired": {
+        "message": "Client Id is required."
+    },
+    "invalidClientId": {
+        "message": "Invalid Client Id provided."
+    },
+    "clientSecretRequired": {
+        "message": "Client Secret is required."
+    },
+    "orgApiKeyRequired": {
+        "message": "Api Key must belong to an Organization"
+    },
+    "failedToSaveCredentials": {
+        "message": "Failed to save credentials"
+    },
     "invalidEmail": {
         "message": "Invalid email address."
     },
     "masterPassRequired": {
         "message": "Master password is required."
     },
+    "missingRequiredInput": {
+        "message": "Missing required input."
+    },
     "unexpectedError": {
         "message": "An unexpected error has occurred."
     },
@@ -336,6 +354,9 @@
     "rootPath": {
         "message": "Root Path"
     },
+    "identityAuthority": {
+        "message": "Identity Authority"
+    },
     "tenant": {
         "message": "Tenant"
     },
@@ -402,6 +423,12 @@
     "groupFilter": {
         "message": "Group Filter"
     },
+    "syncGroupsOneLogin": {
+        "message": "Sync roles"
+    },
+    "groupFilterOneLogin": {
+        "message": "Role Filter"
+    },
     "groupObjectClass": {
         "message": "Group Object Class"
     },
@@ -417,6 +444,19 @@
     "sync": {
         "message": "Sync"
     },
+    "duplicateEmails": {
+        "message": "Emails must be unique. Multiple entries pulled with the following emails:",
+        "desription": "Error message displayed when duplicate email addresses are synced. Followed by a list of duplicate emails."
+    },
+    "andMore": {
+        "message": "and $NUMBER$ more...",
+        "placeholders": {
+            "NUMBER": {
+                "content": "$1",
+                "example": "10"
+            }
+        }
+    },
     "ldapEncrypted": {
         "message": "This server uses an encrypted connection"
     },
@@ -569,7 +609,7 @@
         "message": "Welcome to the Bitwarden Directory Connector"
     },
     "logInDesc": {
-        "message": "Log in as an organization admin user below."
+        "message": "Log in with an organization API key below."
     },
     "dirConfigIncomplete": {
         "message": "Directory configuration incomplete."
@@ -603,6 +643,9 @@
             }
         }
     },
+    "largeImport": {
+        "message": "More than 2000 users or groups are expected to sync."
+    },
     "overwriteExisting": {
         "message": "Overwrite existing organization users based on current sync settings."
     },

src/main.ts

@@ -1,109 +1,155 @@
-import { app } from 'electron';
-import * as path from 'path';
+import { app } from "electron";
+import * as path from "path";
 
-import { MenuMain } from './main/menu.main';
-import { MessagingMain } from './main/messaging.main';
-import { I18nService } from './services/i18n.service';
+import { MenuMain } from "./main/menu.main";
+import { MessagingMain } from "./main/messaging.main";
+import { I18nService } from "./services/i18n.service";
 
-import { KeytarStorageListener } from 'jslib/electron/keytarStorageListener';
-import { ElectronLogService } from 'jslib/electron/services/electronLog.service';
-import { ElectronMainMessagingService } from 'jslib/electron/services/electronMainMessaging.service';
-import { ElectronStorageService } from 'jslib/electron/services/electronStorage.service';
-import { TrayMain } from 'jslib/electron/tray.main';
-import { UpdaterMain } from 'jslib/electron/updater.main';
-import { WindowMain } from 'jslib/electron/window.main';
+import { KeytarStorageListener } from "jslib-electron/keytarStorageListener";
+import { ElectronLogService } from "jslib-electron/services/electronLog.service";
+import { ElectronMainMessagingService } from "jslib-electron/services/electronMainMessaging.service";
+import { ElectronStorageService } from "jslib-electron/services/electronStorage.service";
+import { TrayMain } from "jslib-electron/tray.main";
+import { UpdaterMain } from "jslib-electron/updater.main";
+import { WindowMain } from "jslib-electron/window.main";
+
+import { StateService } from "./services/state.service";
+
+import { Account } from "./models/account";
+
+import { StateFactory } from "jslib-common/factories/stateFactory";
+
+import { GlobalState } from "jslib-common/models/domain/globalState";
 
 export class Main {
-    logService: ElectronLogService;
-    i18nService: I18nService;
-    storageService: ElectronStorageService;
-    messagingService: ElectronMainMessagingService;
-    keytarStorageListener: KeytarStorageListener;
+  logService: ElectronLogService;
+  i18nService: I18nService;
+  storageService: ElectronStorageService;
+  messagingService: ElectronMainMessagingService;
+  keytarStorageListener: KeytarStorageListener;
+  stateService: StateService;
 
-    windowMain: WindowMain;
-    messagingMain: MessagingMain;
-    menuMain: MenuMain;
-    updaterMain: UpdaterMain;
-    trayMain: TrayMain;
+  windowMain: WindowMain;
+  messagingMain: MessagingMain;
+  menuMain: MenuMain;
+  updaterMain: UpdaterMain;
+  trayMain: TrayMain;
 
-    constructor() {
-        // Set paths for portable builds
-        let appDataPath = null;
-        if (process.env.BITWARDEN_CONNECTOR_APPDATA_DIR != null) {
-            appDataPath = process.env.BITWARDEN_CONNECTOR_APPDATA_DIR;
-        } else if (process.platform === 'win32' && process.env.PORTABLE_EXECUTABLE_DIR != null) {
-            appDataPath = path.join(process.env.PORTABLE_EXECUTABLE_DIR, 'bitwarden-connector-appdata');
-        }
-
-        if (appDataPath != null) {
-            app.setPath('userData', appDataPath);
-        }
-        app.setPath('logs', path.join(app.getPath('userData'), 'logs'));
-
-        const args = process.argv.slice(1);
-        const watch = args.some(val => val === '--watch');
-
-        if (watch) {
-            // tslint:disable-next-line
-            require('electron-reload')(__dirname, {});
-        }
-
-        this.logService = new ElectronLogService(null, app.getPath('userData'));
-        this.i18nService = new I18nService('en', './locales/');
-        this.storageService = new ElectronStorageService(app.getPath('userData'));
-
-        this.windowMain = new WindowMain(this.storageService, false, 800, 600, arg => this.processDeepLink(arg), null);
-        this.menuMain = new MenuMain(this);
-        this.updaterMain = new UpdaterMain(this.i18nService, this.windowMain, 'directory-connector', () => {
-            this.messagingService.send('checkingForUpdate');
-        }, () => {
-            this.messagingService.send('doneCheckingForUpdate');
-        }, () => {
-            this.messagingService.send('doneCheckingForUpdate');
-        }, 'bitwardenDirectoryConnector');
-        this.trayMain = new TrayMain(this.windowMain, this.i18nService, this.storageService);
-        this.messagingMain = new MessagingMain(this.windowMain, this.menuMain, this.updaterMain, this.trayMain);
-        this.messagingService = new ElectronMainMessagingService(this.windowMain, message => {
-            this.messagingMain.onMessage(message);
-        });
-
-        this.keytarStorageListener = new KeytarStorageListener('Bitwarden Directory Connector');
+  constructor() {
+    // Set paths for portable builds
+    let appDataPath = null;
+    if (process.env.BITWARDEN_CONNECTOR_APPDATA_DIR != null) {
+      appDataPath = process.env.BITWARDEN_CONNECTOR_APPDATA_DIR;
+    } else if (process.platform === "win32" && process.env.PORTABLE_EXECUTABLE_DIR != null) {
+      appDataPath = path.join(process.env.PORTABLE_EXECUTABLE_DIR, "bitwarden-connector-appdata");
     }
 
-    bootstrap() {
-        this.keytarStorageListener.init();
-        this.windowMain.init().then(async () => {
-            await this.i18nService.init(app.getLocale());
-            this.menuMain.init();
-            this.messagingMain.init();
-            await this.updaterMain.init();
-            await this.trayMain.init(this.i18nService.t('bitwardenDirectoryConnector'));
+    if (appDataPath != null) {
+      app.setPath("userData", appDataPath);
+    }
+    app.setPath("logs", path.join(app.getPath("userData"), "logs"));
 
-            if (!app.isDefaultProtocolClient('bwdc')) {
-                app.setAsDefaultProtocolClient('bwdc');
-            }
+    const args = process.argv.slice(1);
+    const watch = args.some((val) => val === "--watch");
 
-            // Process protocol for macOS
-            app.on('open-url', (event, url) => {
-                event.preventDefault();
-                this.processDeepLink([url]);
-            });
-        }, (e: any) => {
-            // tslint:disable-next-line
-            console.error(e);
-        });
+    if (watch) {
+      // tslint:disable-next-line
+      require("electron-reload")(__dirname, {});
     }
 
-    private processDeepLink(argv: string[]): void {
-        argv.filter(s => s.indexOf('bwdc://') === 0).forEach(s => {
-            const url = new URL(s);
-            const code = url.searchParams.get('code');
-            const receivedState = url.searchParams.get('state');
-            if (code != null && receivedState != null) {
-                this.messagingService.send('ssoCallback', { code: code, state: receivedState });
-            }
+    this.logService = new ElectronLogService(null, app.getPath("userData"));
+    this.i18nService = new I18nService("en", "./locales/");
+    this.storageService = new ElectronStorageService(app.getPath("userData"));
+    this.stateService = new StateService(
+      this.storageService,
+      null,
+      this.logService,
+      null,
+      true,
+      new StateFactory(GlobalState, Account)
+    );
+
+    this.windowMain = new WindowMain(
+      this.stateService,
+      this.logService,
+      false,
+      800,
+      600,
+      (arg) => this.processDeepLink(arg),
+      null
+    );
+
+    this.menuMain = new MenuMain(this);
+    this.updaterMain = new UpdaterMain(
+      this.i18nService,
+      this.windowMain,
+      "directory-connector",
+      () => {
+        this.messagingService.send("checkingForUpdate");
+      },
+      () => {
+        this.messagingService.send("doneCheckingForUpdate");
+      },
+      () => {
+        this.messagingService.send("doneCheckingForUpdate");
+      },
+      "bitwardenDirectoryConnector"
+    );
+
+    this.trayMain = new TrayMain(this.windowMain, this.i18nService, this.stateService);
+
+    this.messagingMain = new MessagingMain(
+      this.windowMain,
+      this.menuMain,
+      this.updaterMain,
+      this.trayMain
+    );
+    this.messagingService = new ElectronMainMessagingService(this.windowMain, (message) => {
+      this.messagingMain.onMessage(message);
+    });
+
+    this.keytarStorageListener = new KeytarStorageListener("Bitwarden Directory Connector", null);
+  }
+
+  bootstrap() {
+    this.keytarStorageListener.init();
+    this.windowMain.init().then(
+      async () => {
+        await this.i18nService.init(app.getLocale());
+        this.menuMain.init();
+        this.messagingMain.init();
+        await this.updaterMain.init();
+        await this.trayMain.init(this.i18nService.t("bitwardenDirectoryConnector"));
+
+        if (!app.isDefaultProtocolClient("bwdc")) {
+          app.setAsDefaultProtocolClient("bwdc");
+        }
+
+        // Process protocol for macOS
+        app.on("open-url", (event, url) => {
+          event.preventDefault();
+          this.processDeepLink([url]);
         });
-    }
+      },
+      (e: any) => {
+        // tslint:disable-next-line
+        console.error(e);
+      }
+    );
+  }
+
+  private processDeepLink(argv: string[]): void {
+    argv
+      .filter((s) => s.indexOf("bwdc://") === 0)
+      .forEach((s) => {
+        const url = new URL(s);
+        const code = url.searchParams.get("code");
+        const receivedState = url.searchParams.get("state");
+        if (code != null && receivedState != null) {
+          this.messagingService.send("ssoCallback", { code: code, state: receivedState });
+        }
+      });
+  }
 }
 
 const main = new Main();

src/main/menu.main.ts

@@ -1,68 +1,69 @@
-import {
-    Menu,
-    MenuItem,
-    MenuItemConstructorOptions,
-} from 'electron';
+import { Menu, MenuItem, MenuItemConstructorOptions } from "electron";
 
-import { Main } from '../main';
+import { Main } from "../main";
 
-import { BaseMenu } from 'jslib/electron/baseMenu';
+import { BaseMenu } from "jslib-electron/baseMenu";
 
 export class MenuMain extends BaseMenu {
-    menu: Menu;
+  menu: Menu;
 
-    constructor(private main: Main) {
-        super(main.i18nService, main.windowMain);
+  constructor(private main: Main) {
+    super(main.i18nService, main.windowMain);
+  }
+
+  init() {
+    this.initProperties();
+    this.initContextMenu();
+    this.initApplicationMenu();
+  }
+
+  private initApplicationMenu() {
+    const template: MenuItemConstructorOptions[] = [
+      this.editMenuItemOptions,
+      {
+        label: this.i18nService.t("view"),
+        submenu: this.viewSubMenuItemOptions,
+      },
+      this.windowMenuItemOptions,
+    ];
+
+    if (process.platform === "darwin") {
+      const firstMenuPart: MenuItemConstructorOptions[] = [
+        {
+          label: this.i18nService.t("aboutBitwarden"),
+          role: "about",
+        },
+      ];
+
+      template.unshift({
+        label: this.main.i18nService.t("bitwardenDirectoryConnector"),
+        submenu: firstMenuPart.concat(this.macAppMenuItemOptions),
+      });
+
+      // Window menu
+      template[template.length - 1].submenu = this.macWindowSubmenuOptions;
     }
 
-    init() {
-        this.initProperties();
-        this.initContextMenu();
-        this.initApplicationMenu();
-    }
+    (template[template.length - 1].submenu as MenuItemConstructorOptions[]).splice(
+      1,
+      0,
+      {
+        label: this.main.i18nService.t(
+          process.platform === "darwin" ? "hideToMenuBar" : "hideToTray"
+        ),
+        click: () => this.main.messagingService.send("hideToTray"),
+        accelerator: "CmdOrCtrl+Shift+M",
+      },
+      {
+        type: "checkbox",
+        label: this.main.i18nService.t("alwaysOnTop"),
+        checked: this.windowMain.win.isAlwaysOnTop(),
+        click: () => this.main.windowMain.toggleAlwaysOnTop(),
+        accelerator: "CmdOrCtrl+Shift+T",
+      }
+    );
 
-    private initApplicationMenu() {
-        const template: MenuItemConstructorOptions[] = [
-            this.editMenuItemOptions,
-            {
-                label: this.i18nService.t('view'),
-                submenu: this.viewSubMenuItemOptions,
-            },
-            this.windowMenuItemOptions,
-        ];
-
-        if (process.platform === 'darwin') {
-            const firstMenuPart: MenuItemConstructorOptions[] = [
-                {
-                    label: this.i18nService.t('aboutBitwarden'),
-                    role: 'about',
-                },
-            ];
-
-            template.unshift({
-                label: this.main.i18nService.t('bitwardenDirectoryConnector'),
-                submenu: firstMenuPart.concat(this.macAppMenuItemOptions),
-            });
-
-            // Window menu
-            template[template.length - 1].submenu = this.macWindowSubmenuOptions;
-        }
-
-        (template[template.length - 1].submenu as MenuItemConstructorOptions[]).splice(1, 0,
-            {
-                label: this.main.i18nService.t(process.platform === 'darwin' ? 'hideToMenuBar' : 'hideToTray'),
-                click: () => this.main.messagingService.send('hideToTray'),
-                accelerator: 'CmdOrCtrl+Shift+M',
-            },
-            {
-                type: 'checkbox',
-                label: this.main.i18nService.t('alwaysOnTop'),
-                checked: this.windowMain.win.isAlwaysOnTop(),
-                click: () => this.main.windowMain.toggleAlwaysOnTop(),
-                accelerator: 'CmdOrCtrl+Shift+T',
-            });
-
-        this.menu = Menu.buildFromTemplate(template);
-        Menu.setApplicationMenu(this.menu);
-    }
+    this.menu = Menu.buildFromTemplate(template);
+    Menu.setApplicationMenu(this.menu);
+  }
 }

src/main/messaging.main.ts

@@ -1,67 +1,68 @@
-import {
-    app,
-    ipcMain,
-} from 'electron';
+import { app, ipcMain } from "electron";
 
-import { TrayMain } from 'jslib/electron/tray.main';
-import { UpdaterMain } from 'jslib/electron/updater.main';
-import { WindowMain } from 'jslib/electron/window.main';
+import { TrayMain } from "jslib-electron/tray.main";
+import { UpdaterMain } from "jslib-electron/updater.main";
+import { WindowMain } from "jslib-electron/window.main";
 
-import { MenuMain } from './menu.main';
+import { MenuMain } from "./menu.main";
 
 const SyncCheckInterval = 60 * 1000; // 1 minute
 
 export class MessagingMain {
-    private syncTimeout: NodeJS.Timer;
+  private syncTimeout: NodeJS.Timer;
 
-    constructor(private windowMain: WindowMain, private menuMain: MenuMain,
-        private updaterMain: UpdaterMain, private trayMain: TrayMain) { }
+  constructor(
+    private windowMain: WindowMain,
+    private menuMain: MenuMain,
+    private updaterMain: UpdaterMain,
+    private trayMain: TrayMain
+  ) {}
 
-    init() {
-        ipcMain.on('messagingService', async (event: any, message: any) => this.onMessage(message));
-    }
+  init() {
+    ipcMain.on("messagingService", async (event: any, message: any) => this.onMessage(message));
+  }
 
-    onMessage(message: any) {
-        switch (message.command) {
-            case 'checkForUpdate':
-                this.updaterMain.checkForUpdate(true);
-                break;
-            case 'scheduleNextDirSync':
-                this.scheduleNextSync();
-                break;
-            case 'cancelDirSync':
-                this.windowMain.win.webContents.send('messagingService', {
-                    command: 'syncScheduleStopped',
-                });
-                if (this.syncTimeout) {
-                    global.clearTimeout(this.syncTimeout);
-                }
-                break;
-            case 'hideToTray':
-                this.trayMain.hideToTray();
-                break;
-            default:
-                break;
-        }
-    }
-
-    private scheduleNextSync() {
-        this.windowMain.win.webContents.send('messagingService', {
-            command: 'syncScheduleStarted',
+  onMessage(message: any) {
+    switch (message.command) {
+      case "checkForUpdate":
+        this.updaterMain.checkForUpdate(true);
+        break;
+      case "scheduleNextDirSync":
+        this.scheduleNextSync();
+        break;
+      case "cancelDirSync":
+        this.windowMain.win.webContents.send("messagingService", {
+          command: "syncScheduleStopped",
         });
-
         if (this.syncTimeout) {
-            global.clearTimeout(this.syncTimeout);
+          global.clearTimeout(this.syncTimeout);
         }
-
-        this.syncTimeout = global.setTimeout(() => {
-            if (this.windowMain.win == null) {
-                return;
-            }
-
-            this.windowMain.win.webContents.send('messagingService', {
-                command: 'checkDirSync',
-            });
-        }, SyncCheckInterval);
+        break;
+      case "hideToTray":
+        this.trayMain.hideToTray();
+        break;
+      default:
+        break;
     }
+  }
+
+  private scheduleNextSync() {
+    this.windowMain.win.webContents.send("messagingService", {
+      command: "syncScheduleStarted",
+    });
+
+    if (this.syncTimeout) {
+      global.clearTimeout(this.syncTimeout);
+    }
+
+    this.syncTimeout = global.setTimeout(() => {
+      if (this.windowMain.win == null) {
+        return;
+      }
+
+      this.windowMain.win.webContents.send("messagingService", {
+        command: "checkDirSync",
+      });
+    }, SyncCheckInterval);
+  }
 }

src/models/IConfiguration.ts

@@ -0,0 +1,2 @@
+// tslint:disable-next-line
+export interface IConfiguration {}

src/models/account.ts

@@ -0,0 +1,47 @@
+import { Account as BaseAccount } from "jslib-common/models/domain/account";
+
+import { DirectoryType } from "src/enums/directoryType";
+
+import { AzureConfiguration } from "./azureConfiguration";
+import { GSuiteConfiguration } from "./gsuiteConfiguration";
+import { LdapConfiguration } from "./ldapConfiguration";
+import { OktaConfiguration } from "./oktaConfiguration";
+import { OneLoginConfiguration } from "./oneLoginConfiguration";
+import { SyncConfiguration } from "./syncConfiguration";
+
+export class Account extends BaseAccount {
+  directoryConfigurations?: DirectoryConfigurations = new DirectoryConfigurations();
+  directorySettings: DirectorySettings = new DirectorySettings();
+  clientKeys: ClientKeys = new ClientKeys();
+
+  constructor(init: Partial<Account>) {
+    super(init);
+    this.directoryConfigurations = init?.directoryConfigurations ?? new DirectoryConfigurations();
+    this.directorySettings = init?.directorySettings ?? new DirectorySettings();
+  }
+}
+
+export class ClientKeys {
+  clientId: string;
+  clientSecret: string;
+}
+
+export class DirectoryConfigurations {
+  ldap: LdapConfiguration;
+  gsuite: GSuiteConfiguration;
+  azure: AzureConfiguration;
+  okta: OktaConfiguration;
+  oneLogin: OneLoginConfiguration;
+}
+
+export class DirectorySettings {
+  organizationId?: string;
+  sync?: SyncConfiguration;
+  directoryType?: DirectoryType;
+  userDelta?: string;
+  groupDelta?: string;
+  lastUserSync?: Date;
+  lastGroupSync?: Date;
+  lastSyncHash?: string;
+  syncingDir?: boolean;
+}

src/models/azureConfiguration.ts

@@ -1,5 +1,8 @@
-export class AzureConfiguration {
-    tenant: string;
-    applicationId: string;
-    key: string;
+import { IConfiguration } from "./IConfiguration";
+
+export class AzureConfiguration implements IConfiguration {
+  identityAuthority: string;
+  tenant: string;
+  applicationId: string;
+  key: string;
 }

src/models/entry.ts

@@ -1,8 +1,8 @@
 export abstract class Entry {
-    referenceId: string;
-    externalId: string;
+  referenceId: string;
+  externalId: string;
 
-    get displayName(): string {
-        return this.referenceId;
-    }
+  get displayName(): string {
+    return this.referenceId;
+  }
 }

src/models/groupEntry.ts

@@ -1,15 +1,15 @@
-import { Entry } from './entry';
+import { Entry } from "./entry";
 
 export class GroupEntry extends Entry {
-    name: string;
-    userMemberExternalIds = new Set<string>();
-    groupMemberReferenceIds = new Set<string>();
+  name: string;
+  userMemberExternalIds = new Set<string>();
+  groupMemberReferenceIds = new Set<string>();
 
-    get displayName(): string {
-        if (this.name == null) {
-            return this.referenceId;
-        }
-
-        return this.name;
+  get displayName(): string {
+    if (this.name == null) {
+      return this.referenceId;
     }
+
+    return this.name;
+  }
 }

src/models/gsuiteConfiguration.ts

@@ -1,7 +1,9 @@
-export class GSuiteConfiguration {
-    clientEmail: string;
-    privateKey: string;
-    domain: string;
-    adminUser: string;
-    customer: string;
+import { IConfiguration } from "./IConfiguration";
+
+export class GSuiteConfiguration implements IConfiguration {
+  clientEmail: string;
+  privateKey: string;
+  domain: string;
+  adminUser: string;
+  customer: string;
 }

src/models/ldapConfiguration.ts

@@ -1,18 +1,20 @@
-export class LdapConfiguration {
-    ssl = false;
-    startTls = false;
-    tlsCaPath: string;
-    sslAllowUnauthorized = false;
-    sslCertPath: string;
-    sslKeyPath: string;
-    sslCaPath: string;
-    hostname: string;
-    port = 389;
-    domain: string;
-    rootPath: string;
-    currentUser = false;
-    username: string;
-    password: string;
-    ad = true;
-    pagedSearch = true;
+import { IConfiguration } from "./IConfiguration";
+
+export class LdapConfiguration implements IConfiguration {
+  ssl = false;
+  startTls = false;
+  tlsCaPath: string;
+  sslAllowUnauthorized = false;
+  sslCertPath: string;
+  sslKeyPath: string;
+  sslCaPath: string;
+  hostname: string;
+  port = 389;
+  domain: string;
+  rootPath: string;
+  currentUser = false;
+  username: string;
+  password: string;
+  ad = true;
+  pagedSearch = true;
 }

src/models/oktaConfiguration.ts

@@ -1,4 +1,6 @@
-export class OktaConfiguration {
-    orgUrl: string;
-    token: string;
+import { IConfiguration } from "./IConfiguration";
+
+export class OktaConfiguration implements IConfiguration {
+  orgUrl: string;
+  token: string;
 }

src/models/oneLoginConfiguration.ts

@@ -1,5 +1,7 @@
-export class OneLoginConfiguration {
-    clientId: string;
-    clientSecret: string;
-    region = 'us';
+import { IConfiguration } from "./IConfiguration";
+
+export class OneLoginConfiguration implements IConfiguration {
+  clientId: string;
+  clientSecret: string;
+  region = "us";
 }

src/models/response/groupResponse.ts

@@ -1,13 +1,13 @@
-import { GroupEntry } from '../groupEntry';
+import { GroupEntry } from "../groupEntry";
 
 export class GroupResponse {
-    externalId: string;
-    displayName: string;
-    userIds: string[];
+  externalId: string;
+  displayName: string;
+  userIds: string[];
 
-    constructor(g: GroupEntry) {
-        this.externalId = g.externalId;
-        this.displayName = g.displayName;
-        this.userIds = Array.from(g.userMemberExternalIds);
-    }
+  constructor(g: GroupEntry) {
+    this.externalId = g.externalId;
+    this.displayName = g.displayName;
+    this.userIds = Array.from(g.userMemberExternalIds);
+  }
 }

src/models/response/testResponse.ts

@@ -1,22 +1,25 @@
-import { GroupResponse } from './groupResponse';
-import { UserResponse } from './userResponse';
+import { GroupResponse } from "./groupResponse";
+import { UserResponse } from "./userResponse";
 
-import { SimResult } from '../simResult';
+import { SimResult } from "../simResult";
 
-import { BaseResponse } from 'jslib/cli/models/response/baseResponse';
+import { BaseResponse } from "jslib-node/cli/models/response/baseResponse";
 
 export class TestResponse implements BaseResponse {
-    object: string;
-    groups: GroupResponse[] = [];
-    enabledUsers: UserResponse[] = [];
-    disabledUsers: UserResponse[] = [];
-    deletedUsers: UserResponse[] = [];
+  object: string;
+  groups: GroupResponse[] = [];
+  enabledUsers: UserResponse[] = [];
+  disabledUsers: UserResponse[] = [];
+  deletedUsers: UserResponse[] = [];
 
-    constructor(result: SimResult) {
-        this.object = 'test';
-        this.groups = result.groups != null ? result.groups.map(g => new GroupResponse(g)) : [];
-        this.enabledUsers = result.enabledUsers != null ? result.enabledUsers.map(u => new UserResponse(u)) : [];
-        this.disabledUsers = result.disabledUsers != null ? result.disabledUsers.map(u => new UserResponse(u)) : [];
-        this.deletedUsers = result.deletedUsers != null ? result.deletedUsers.map(u => new UserResponse(u)) : [];
-    }
+  constructor(result: SimResult) {
+    this.object = "test";
+    this.groups = result.groups != null ? result.groups.map((g) => new GroupResponse(g)) : [];
+    this.enabledUsers =
+      result.enabledUsers != null ? result.enabledUsers.map((u) => new UserResponse(u)) : [];
+    this.disabledUsers =
+      result.disabledUsers != null ? result.disabledUsers.map((u) => new UserResponse(u)) : [];
+    this.deletedUsers =
+      result.deletedUsers != null ? result.deletedUsers.map((u) => new UserResponse(u)) : [];
+  }
 }

src/models/response/userResponse.ts

@@ -1,11 +1,11 @@
-import { UserEntry } from '../userEntry';
+import { UserEntry } from "../userEntry";
 
 export class UserResponse {
-    externalId: string;
-    displayName: string;
+  externalId: string;
+  displayName: string;
 
-    constructor(u: UserEntry) {
-        this.externalId = u.externalId;
-        this.displayName = u.displayName;
-    }
+  constructor(u: UserEntry) {
+    this.externalId = u.externalId;
+    this.displayName = u.displayName;
+  }
 }

src/models/simResult.ts

@@ -1,10 +1,10 @@
-import { GroupEntry } from './groupEntry';
-import { UserEntry } from './userEntry';
+import { GroupEntry } from "./groupEntry";
+import { UserEntry } from "./userEntry";
 
 export class SimResult {
-    groups: GroupEntry[] = [];
-    users: UserEntry[] = [];
-    enabledUsers: UserEntry[] = [];
-    disabledUsers: UserEntry[] = [];
-    deletedUsers: UserEntry[] = [];
+  groups: GroupEntry[] = [];
+  users: UserEntry[] = [];
+  enabledUsers: UserEntry[] = [];
+  disabledUsers: UserEntry[] = [];
+  deletedUsers: UserEntry[] = [];
 }

src/models/syncConfiguration.ts

@@ -1,22 +1,23 @@
 export class SyncConfiguration {
-    users = false;
-    groups = false;
-    interval = 5;
-    userFilter: string;
-    groupFilter: string;
-    removeDisabled = false;
-    overwriteExisting = false;
-    // Ldap properties
-    groupObjectClass: string;
-    userObjectClass: string;
-    groupPath: string;
-    userPath: string;
-    groupNameAttribute: string;
-    userEmailAttribute: string;
-    memberAttribute: string;
-    useEmailPrefixSuffix = false;
-    emailPrefixAttribute: string;
-    emailSuffix: string;
-    creationDateAttribute: string;
-    revisionDateAttribute: string;
+  users = false;
+  groups = false;
+  interval = 5;
+  userFilter: string;
+  groupFilter: string;
+  removeDisabled = false;
+  overwriteExisting = false;
+  largeImport = false;
+  // Ldap properties
+  groupObjectClass: string;
+  userObjectClass: string;
+  groupPath: string;
+  userPath: string;
+  groupNameAttribute: string;
+  userEmailAttribute: string;
+  memberAttribute: string;
+  useEmailPrefixSuffix = false;
+  emailPrefixAttribute: string;
+  emailSuffix: string;
+  creationDateAttribute: string;
+  revisionDateAttribute: string;
 }

src/models/userEntry.ts

@@ -1,15 +1,15 @@
-import { Entry } from './entry';
+import { Entry } from "./entry";
 
 export class UserEntry extends Entry {
-    email: string;
-    disabled = false;
-    deleted = false;
+  email: string;
+  disabled = false;
+  deleted = false;
 
-    get displayName(): string {
-        if (this.email == null) {
-            return this.referenceId;
-        }
-
-        return this.email;
+  get displayName(): string {
+    if (this.email == null) {
+      return this.referenceId;
     }
+
+    return this.email;
+  }
 }

src/package.json

@@ -1,8 +1,8 @@
 {
-  "name": "bitwarden-directory-connector",
+  "name": "@bitwarden/directory-connector",
   "productName": "Bitwarden Directory Connector",
   "description": "Sync your user directory to your Bitwarden organization.",
-  "version": "2.9.2",
+  "version": "2.9.9",
   "author": "Bitwarden Inc. <hello@bitwarden.com> (https://bitwarden.com)",
   "homepage": "https://bitwarden.com",
   "license": "GPL-3.0",
@@ -13,9 +13,9 @@
   },
   "dependencies": {
     "browser-hrtime": "^1.1.8",
-    "electron-log": "4.3.0",
-    "electron-store": "6.0.1",
-    "electron-updater": "4.3.5",
-    "keytar": "7.3.0"
+    "electron-log": "4.4.1",
+    "electron-store": "8.0.1",
+    "electron-updater": "4.6.1",
+    "keytar": "7.7.0"
   }
 }

src/program.ts

@@ -1,283 +1,321 @@
-import * as chk from 'chalk';
-import * as program from 'commander';
-import * as path from 'path';
+import * as chalk from "chalk";
+import * as program from "commander";
+import * as path from "path";
 
-import { Main } from './bwdc';
+import { Main } from "./bwdc";
 
-import { ClearCacheCommand } from './commands/clearCache.command';
-import { ConfigCommand } from './commands/config.command';
-import { LastSyncCommand } from './commands/lastSync.command';
-import { SyncCommand } from './commands/sync.command';
-import { TestCommand } from './commands/test.command';
+import { ClearCacheCommand } from "./commands/clearCache.command";
+import { ConfigCommand } from "./commands/config.command";
+import { LastSyncCommand } from "./commands/lastSync.command";
+import { SyncCommand } from "./commands/sync.command";
+import { TestCommand } from "./commands/test.command";
 
-import { LoginCommand } from 'jslib/cli/commands/login.command';
-import { LogoutCommand } from 'jslib/cli/commands/logout.command';
-import { UpdateCommand } from 'jslib/cli/commands/update.command';
+import { LoginCommand } from "jslib-node/cli/commands/login.command";
+import { LogoutCommand } from "jslib-node/cli/commands/logout.command";
+import { UpdateCommand } from "jslib-node/cli/commands/update.command";
 
-import { BaseProgram } from 'jslib/cli/baseProgram';
+import { BaseProgram } from "jslib-node/cli/baseProgram";
 
-import { Response } from 'jslib/cli/models/response';
-import { StringResponse } from 'jslib/cli/models/response/stringResponse';
+import { Response } from "jslib-node/cli/models/response";
+import { StringResponse } from "jslib-node/cli/models/response/stringResponse";
+
+import { Utils } from "jslib-common/misc/utils";
 
-const chalk = chk.default;
 const writeLn = (s: string, finalLine: boolean = false, error: boolean = false) => {
-    const stream = error ? process.stderr : process.stdout;
-    if (finalLine && process.platform === 'win32') {
-        stream.write(s);
-    } else {
-        stream.write(s + '\n');
-    }
+  const stream = error ? process.stderr : process.stdout;
+  if (finalLine && process.platform === "win32") {
+    stream.write(s);
+  } else {
+    stream.write(s + "\n");
+  }
 };
 
 export class Program extends BaseProgram {
-    constructor(private main: Main) {
-        super(main.userService, writeLn);
-    }
+  constructor(private main: Main) {
+    super(main.stateService, writeLn);
+  }
 
-    async run() {
-        program
-            .option('--pretty', 'Format output. JSON is tabbed with two spaces.')
-            .option('--raw', 'Return raw output instead of a descriptive message.')
-            .option('--response', 'Return a JSON formatted version of response output.')
-            .option('--quiet', 'Don\'t return anything to stdout.')
-            .option('--nointeraction', 'Do not prompt for interactive user input.')
-            .version(await this.main.platformUtilsService.getApplicationVersion(), '-v, --version');
+  async run() {
+    program
+      .option("--pretty", "Format output. JSON is tabbed with two spaces.")
+      .option("--raw", "Return raw output instead of a descriptive message.")
+      .option("--response", "Return a JSON formatted version of response output.")
+      .option("--cleanexit", "Exit with a success exit code (0) unless an error is thrown.")
+      .option("--quiet", "Don't return anything to stdout.")
+      .option("--nointeraction", "Do not prompt for interactive user input.")
+      .version(await this.main.platformUtilsService.getApplicationVersion(), "-v, --version");
 
-        program.on('option:pretty', () => {
-            process.env.BW_PRETTY = 'true';
-        });
+    program.on("option:pretty", () => {
+      process.env.BW_PRETTY = "true";
+    });
 
-        program.on('option:raw', () => {
-            process.env.BW_RAW = 'true';
-        });
+    program.on("option:raw", () => {
+      process.env.BW_RAW = "true";
+    });
 
-        program.on('option:quiet', () => {
-            process.env.BW_QUIET = 'true';
-        });
+    program.on("option:quiet", () => {
+      process.env.BW_QUIET = "true";
+    });
 
-        program.on('option:response', () => {
-            process.env.BW_RESPONSE = 'true';
-        });
+    program.on("option:response", () => {
+      process.env.BW_RESPONSE = "true";
+    });
 
-        program.on('option:nointeraction', () => {
-            process.env.BW_NOINTERACTION = 'true';
-        });
+    program.on("option:cleanexit", () => {
+      process.env.BW_CLEANEXIT = "true";
+    });
 
-        program.on('command:*', () => {
-            writeLn(chalk.redBright('Invalid command: ' + program.args.join(' ')), false, true);
-            writeLn('See --help for a list of available commands.', true, true);
-            process.exitCode = 1;
-        });
+    program.on("option:nointeraction", () => {
+      process.env.BW_NOINTERACTION = "true";
+    });
 
-        program.on('--help', () => {
-            writeLn('\n  Examples:');
-            writeLn('');
-            writeLn('    bwdc login');
-            writeLn('    bwdc test');
-            writeLn('    bwdc sync');
-            writeLn('    bwdc last-sync');
-            writeLn('    bwdc config server https://bw.company.com');
-            writeLn('    bwdc update');
-            writeLn('', true);
-        });
+    program.on("command:*", () => {
+      writeLn(chalk.redBright("Invalid command: " + program.args.join(" ")), false, true);
+      writeLn("See --help for a list of available commands.", true, true);
+      process.exitCode = 1;
+    });
 
-        program
-            .command('login [email] [password]')
-            .description('Log into a user account.')
-            .option('--method <method>', 'Two-step login method.')
-            .option('--code <code>', 'Two-step login code.')
-            .option('--sso', 'Log in with Single-Sign On.')
-            .option('--passwordenv <variable-name>', 'Read password from the named environment variable.')
-            .option('--passwordfile <filename>', 'Read password from first line of the named file.')
-            .on('--help', () => {
-                writeLn('\n  Notes:');
-                writeLn('');
-                writeLn('    See docs for valid `method` enum values.');
-                writeLn('');
-                writeLn('  Examples:');
-                writeLn('');
-                writeLn('    bwdc login');
-                writeLn('    bwdc login john@example.com myPassword321');
-                writeLn('    bwdc login john@example.com myPassword321 --method 1 --code 249213');
-                writeLn('    bwdc login john@example.com --passwordfile passwd.txt --method 1 --code 249213');
-                writeLn('    bwdc login john@example.com --passwordenv MY_PASSWD --method 1 --code 249213');
-                writeLn('    bwdc login --sso');
-                writeLn('', true);
-            })
-            .action(async (email: string, password: string, options: program.OptionValues) => {
-                await this.exitIfAuthed();
-                const command = new LoginCommand(this.main.authService, this.main.apiService, this.main.i18nService,
-                    this.main.environmentService, this.main.passwordGenerationService, this.main.cryptoFunctionService,
-                    this.main.platformUtilsService, 'connector');
-                const response = await command.run(email, password, options);
-                this.processResponse(response);
-            });
+    program.on("--help", () => {
+      writeLn("\n  Examples:");
+      writeLn("");
+      writeLn("    bwdc login");
+      writeLn("    bwdc test");
+      writeLn("    bwdc sync");
+      writeLn("    bwdc last-sync");
+      writeLn("    bwdc config server https://bw.company.com");
+      writeLn("    bwdc update");
+      writeLn("", true);
+    });
 
-        program
-            .command('logout')
-            .description('Log out of the current user account.')
-            .on('--help', () => {
-                writeLn('\n  Examples:');
-                writeLn('');
-                writeLn('    bwdc logout');
-                writeLn('', true);
-            })
-            .action(async () => {
-                await this.exitIfNotAuthed();
-                const command = new LogoutCommand(this.main.authService, this.main.i18nService,
-                    async () => await this.main.logout());
-                const response = await command.run();
-                this.processResponse(response);
-            });
+    program
+      .command("login [clientId] [clientSecret]")
+      .description("Log into an organization account.", {
+        clientId: "Client_id part of your organization's API key",
+        clientSecret: "Client_secret part of your organization's API key",
+      })
+      .action(async (clientId: string, clientSecret: string, options: program.OptionValues) => {
+        await this.exitIfAuthed();
+        const command = new LoginCommand(
+          this.main.authService,
+          this.main.apiService,
+          this.main.i18nService,
+          this.main.environmentService,
+          this.main.passwordGenerationService,
+          this.main.cryptoFunctionService,
+          this.main.platformUtilsService,
+          this.main.stateService,
+          this.main.cryptoService,
+          this.main.policyService,
+          "connector"
+        );
 
-        program
-            .command('test')
-            .description('Test a simulated sync.')
-            .option('-l, --last', 'Since the last successful sync.')
-            .on('--help', () => {
-                writeLn('\n  Examples:');
-                writeLn('');
-                writeLn('    bwdc test');
-                writeLn('    bwdc test --last');
-                writeLn('', true);
-            })
-            .action(async (options: program.OptionValues) => {
-                await this.exitIfNotAuthed();
-                const command = new TestCommand(this.main.syncService, this.main.i18nService);
-                const response = await command.run(options);
-                this.processResponse(response);
-            });
-
-        program
-            .command('sync')
-            .description('Sync the directory.')
-            .on('--help', () => {
-                writeLn('\n  Examples:');
-                writeLn('');
-                writeLn('    bwdc sync');
-                writeLn('', true);
-            })
-            .action(async () => {
-                await this.exitIfNotAuthed();
-                const command = new SyncCommand(this.main.syncService, this.main.i18nService);
-                const response = await command.run();
-                this.processResponse(response);
-            });
-
-        program
-            .command('last-sync <object>')
-            .description('Get the last successful sync date.')
-            .on('--help', () => {
-                writeLn('\n  Notes:');
-                writeLn('');
-                writeLn('    Returns empty response if no sync has been performed for the given object.');
-                writeLn('');
-                writeLn('  Examples:');
-                writeLn('');
-                writeLn('    bwdc last-sync groups');
-                writeLn('    bwdc last-sync users');
-                writeLn('', true);
-            })
-            .action(async (object: string) => {
-                await this.exitIfNotAuthed();
-                const command = new LastSyncCommand(this.main.configurationService);
-                const response = await command.run(object);
-                this.processResponse(response);
-            });
-
-        program
-            .command('config <setting> [value]')
-            .description('Configure settings.')
-            .option('--secretenv <variable-name>', 'Read secret from the named environment variable.')
-            .option('--secretfile <filename>', 'Read secret from first line of the named file.')
-            .on('--help', () => {
-                writeLn('\n  Settings:');
-                writeLn('');
-                writeLn('    server - On-premise hosted installation URL.');
-                writeLn('    directory - The type of directory to use.');
-                writeLn('    ldap.password - The password for connection to this LDAP server.');
-                writeLn('    azure.key - The Azure AD secret key.');
-                writeLn('    gsuite.key - The G Suite private key.');
-                writeLn('    okta.token - The Okta token.');
-                writeLn('    onelogin.secret - The OneLogin client secret.');
-                writeLn('');
-                writeLn('  Examples:');
-                writeLn('');
-                writeLn('    bwdc config server https://bw.company.com');
-                writeLn('    bwdc config server bitwarden.com');
-                writeLn('    bwdc config directory 1');
-                writeLn('    bwdc config ldap.password <password>');
-                writeLn('    bwdc config ldap.password --secretenv LDAP_PWD');
-                writeLn('    bwdc config azure.key <key>');
-                writeLn('    bwdc config gsuite.key <key>');
-                writeLn('    bwdc config okta.token <token>');
-                writeLn('    bwdc config onelogin.secret <secret>');
-                writeLn('', true);
-            })
-            .action(async (setting: string, value: string, options: program.OptionValues) => {
-                const command = new ConfigCommand(this.main.environmentService, this.main.i18nService,
-                    this.main.configurationService);
-                const response = await command.run(setting, value, options);
-                this.processResponse(response);
-            });
-
-        program
-            .command('data-file')
-            .description('Path to data.json database file.')
-            .on('--help', () => {
-                writeLn('\n  Examples:');
-                writeLn('');
-                writeLn('    bwdc data-file');
-                writeLn('', true);
-            })
-            .action(() => {
-                this.processResponse(
-                    Response.success(new StringResponse(path.join(this.main.dataFilePath, 'data.json'))));
-            });
-
-        program
-            .command('clear-cache')
-            .description('Clear the sync cache.')
-            .on('--help', () => {
-                writeLn('\n  Examples:');
-                writeLn('');
-                writeLn('    bwdc clear-cache');
-                writeLn('', true);
-            })
-            .action(async (options: program.OptionValues) => {
-                const command = new ClearCacheCommand(this.main.configurationService, this.main.i18nService);
-                const response = await command.run(options);
-                this.processResponse(response);
-            });
-
-        program
-            .command('update')
-            .description('Check for updates.')
-            .on('--help', () => {
-                writeLn('\n  Notes:');
-                writeLn('');
-                writeLn('    Returns the URL to download the newest version of this CLI tool.');
-                writeLn('');
-                writeLn('    Use the `--raw` option to return only the download URL for the update.');
-                writeLn('');
-                writeLn('  Examples:');
-                writeLn('');
-                writeLn('    bwdc update');
-                writeLn('    bwdc update --raw');
-                writeLn('', true);
-            })
-            .action(async () => {
-                const command = new UpdateCommand(this.main.platformUtilsService, this.main.i18nService,
-                    'directory-connector', 'bwdc', false);
-                const response = await command.run();
-                this.processResponse(response);
-            });
-
-        program
-            .parse(process.argv);
-
-        if (process.argv.slice(2).length === 0) {
-            program.outputHelp();
+        if (!Utils.isNullOrWhitespace(clientId)) {
+          process.env.BW_CLIENTID = clientId;
         }
+        if (!Utils.isNullOrWhitespace(clientSecret)) {
+          process.env.BW_CLIENTSECRET = clientSecret;
+        }
+
+        options = Object.assign(options ?? {}, { apikey: true }); // force apikey use
+        const response = await command.run(null, null, options);
+        this.processResponse(response);
+      });
+
+    program
+      .command("logout")
+      .description("Log out of the current user account.")
+      .on("--help", () => {
+        writeLn("\n  Examples:");
+        writeLn("");
+        writeLn("    bwdc logout");
+        writeLn("", true);
+      })
+      .action(async () => {
+        await this.exitIfNotAuthed();
+        const command = new LogoutCommand(
+          this.main.authService,
+          this.main.i18nService,
+          async () => await this.main.logout()
+        );
+        const response = await command.run();
+        this.processResponse(response);
+      });
+
+    program
+      .command("test")
+      .description("Test a simulated sync.")
+      .option("-l, --last", "Since the last successful sync.")
+      .on("--help", () => {
+        writeLn("\n  Examples:");
+        writeLn("");
+        writeLn("    bwdc test");
+        writeLn("    bwdc test --last");
+        writeLn("", true);
+      })
+      .action(async (options: program.OptionValues) => {
+        await this.exitIfNotAuthed();
+        const command = new TestCommand(this.main.syncService, this.main.i18nService);
+        const response = await command.run(options);
+        this.processResponse(response);
+      });
+
+    program
+      .command("sync")
+      .description("Sync the directory.")
+      .on("--help", () => {
+        writeLn("\n  Examples:");
+        writeLn("");
+        writeLn("    bwdc sync");
+        writeLn("", true);
+      })
+      .action(async () => {
+        await this.exitIfNotAuthed();
+        const command = new SyncCommand(this.main.syncService, this.main.i18nService);
+        const response = await command.run();
+        this.processResponse(response);
+      });
+
+    program
+      .command("last-sync <object>")
+      .description("Get the last successful sync date.")
+      .on("--help", () => {
+        writeLn("\n  Notes:");
+        writeLn("");
+        writeLn("    Returns empty response if no sync has been performed for the given object.");
+        writeLn("");
+        writeLn("  Examples:");
+        writeLn("");
+        writeLn("    bwdc last-sync groups");
+        writeLn("    bwdc last-sync users");
+        writeLn("", true);
+      })
+      .action(async (object: string) => {
+        await this.exitIfNotAuthed();
+        const command = new LastSyncCommand(this.main.stateService);
+        const response = await command.run(object);
+        this.processResponse(response);
+      });
+
+    program
+      .command("config <setting> [value]")
+      .description("Configure settings.")
+      .option("--secretenv <variable-name>", "Read secret from the named environment variable.")
+      .option("--secretfile <filename>", "Read secret from first line of the named file.")
+      .on("--help", () => {
+        writeLn("\n  Settings:");
+        writeLn("");
+        writeLn("    server - On-premise hosted installation URL.");
+        writeLn("    directory - The type of directory to use.");
+        writeLn("    ldap.password - The password for connection to this LDAP server.");
+        writeLn("    azure.key - The Azure AD secret key.");
+        writeLn("    gsuite.key - The G Suite private key.");
+        writeLn("    okta.token - The Okta token.");
+        writeLn("    onelogin.secret - The OneLogin client secret.");
+        writeLn("");
+        writeLn("  Examples:");
+        writeLn("");
+        writeLn("    bwdc config server https://bw.company.com");
+        writeLn("    bwdc config server bitwarden.com");
+        writeLn("    bwdc config directory 1");
+        writeLn("    bwdc config ldap.password <password>");
+        writeLn("    bwdc config ldap.password --secretenv LDAP_PWD");
+        writeLn("    bwdc config azure.key <key>");
+        writeLn("    bwdc config gsuite.key <key>");
+        writeLn("    bwdc config okta.token <token>");
+        writeLn("    bwdc config onelogin.secret <secret>");
+        writeLn("", true);
+      })
+      .action(async (setting: string, value: string, options: program.OptionValues) => {
+        const command = new ConfigCommand(
+          this.main.environmentService,
+          this.main.i18nService,
+          this.main.stateService
+        );
+        const response = await command.run(setting, value, options);
+        this.processResponse(response);
+      });
+
+    program
+      .command("data-file")
+      .description("Path to data.json database file.")
+      .on("--help", () => {
+        writeLn("\n  Examples:");
+        writeLn("");
+        writeLn("    bwdc data-file");
+        writeLn("", true);
+      })
+      .action(() => {
+        this.processResponse(
+          Response.success(new StringResponse(path.join(this.main.dataFilePath, "data.json")))
+        );
+      });
+
+    program
+      .command("clear-cache")
+      .description("Clear the sync cache.")
+      .on("--help", () => {
+        writeLn("\n  Examples:");
+        writeLn("");
+        writeLn("    bwdc clear-cache");
+        writeLn("", true);
+      })
+      .action(async (options: program.OptionValues) => {
+        const command = new ClearCacheCommand(this.main.i18nService, this.main.stateService);
+        const response = await command.run(options);
+        this.processResponse(response);
+      });
+
+    program
+      .command("update")
+      .description("Check for updates.")
+      .on("--help", () => {
+        writeLn("\n  Notes:");
+        writeLn("");
+        writeLn("    Returns the URL to download the newest version of this CLI tool.");
+        writeLn("");
+        writeLn("    Use the `--raw` option to return only the download URL for the update.");
+        writeLn("");
+        writeLn("  Examples:");
+        writeLn("");
+        writeLn("    bwdc update");
+        writeLn("    bwdc update --raw");
+        writeLn("", true);
+      })
+      .action(async () => {
+        const command = new UpdateCommand(
+          this.main.platformUtilsService,
+          this.main.i18nService,
+          "directory-connector",
+          "bwdc",
+          false
+        );
+        const response = await command.run();
+        this.processResponse(response);
+      });
+
+    program.parse(process.argv);
+
+    if (process.argv.slice(2).length === 0) {
+      program.outputHelp();
     }
+  }
+
+  async exitIfAuthed() {
+    const authed = await this.stateService.getIsAuthenticated();
+    if (authed) {
+      const type = await this.stateService.getEntityType();
+      const id = await this.stateService.getEntityId();
+      this.processResponse(
+        Response.error("You are already logged in as " + type + "." + id + "."),
+        true
+      );
+    }
+  }
+
+  async exitIfNotAuthed() {
+    const authed = await this.stateService.getIsAuthenticated();
+    if (!authed) {
+      this.processResponse(Response.error("You are not logged in."), true);
+    }
+  }
 }

src/scss/bootstrap.scss

@@ -1,5 +1,15 @@
-$theme-colors: ( "primary": #175DDC, "primary-accent": #1252A3, "danger": #dd4b39, "success": #00a65a, "info": #555555, "warning": #bf7e16, "secondary": #ced4da, "secondary-alt": #1A3B66);
-$font-family-sans-serif: 'Open Sans','Helvetica Neue',Helvetica,Arial,sans-serif, 'Apple Color Emoji', 'Segoe UI Emoji', 'Segoe UI Symbol';
+$theme-colors: (
+  "primary": #175ddc,
+  "primary-accent": #1252a3,
+  "danger": #dd4b39,
+  "success": #00a65a,
+  "info": #555555,
+  "warning": #bf7e16,
+  "secondary": #ced4da,
+  "secondary-alt": #1a3b66,
+);
+$font-family-sans-serif: "Open Sans", "Helvetica Neue", Helvetica, Arial, sans-serif,
+  "Apple Color Emoji", "Segoe UI Emoji", "Segoe UI Symbol";
 
 $h1-font-size: 2rem;
 $h2-font-size: 1.3rem;
@@ -8,13 +18,13 @@ $h4-font-size: 1rem;
 $h5-font-size: 1rem;
 $h6-font-size: 1rem;
 
-$primary: map_get($theme-colors, 'primary'); 
-$primary-accent: map_get($theme-colors, 'primary-accent'); 
-$success: map_get($theme-colors, 'success'); 
-$info: map_get($theme-colors, 'info'); 
-$warning: map_get($theme-colors, 'warning'); 
-$danger: map_get($theme-colors, 'danger'); 
-$secondary: map_get($theme-colors, 'secondary'); 
-$secondary-alt: map_get($theme-colors, 'secondary-alt'); 
+$primary: map_get($theme-colors, "primary");
+$primary-accent: map_get($theme-colors, "primary-accent");
+$success: map_get($theme-colors, "success");
+$info: map_get($theme-colors, "info");
+$warning: map_get($theme-colors, "warning");
+$danger: map_get($theme-colors, "danger");
+$secondary: map_get($theme-colors, "secondary");
+$secondary-alt: map_get($theme-colors, "secondary-alt");
 
 @import "~bootstrap/scss/bootstrap.scss";

src/scss/environment.scss

@@ -1,7 +1,7 @@
 @import "~bootstrap/scss/_variables.scss";
 
 html.os_windows {
-    body {
-        border-top: 1px solid $gray-400;
-    }
+  body {
+    border-top: 1px solid $gray-400;
+  }
 }

src/scss/misc.scss

@@ -1,120 +1,143 @@
 @import "~bootstrap/scss/_variables.scss";
 
 body {
-    padding: 10px 0 20px 0;
+  padding: 10px 0 20px 0;
 }
 
 h1 {
-    border-bottom: 1px solid $border-color;
-    margin-bottom: 20px;
+  border-bottom: 1px solid $border-color;
+  margin-bottom: 20px;
 
-    small {
-        color: $text-muted;
-        font-size: $h1-font-size * .5;
-    }
+  small {
+    color: $text-muted;
+    font-size: $h1-font-size * 0.5;
+  }
 }
 
 h2 {
-    text-transform: uppercase;
-    font-weight: bold;
+  text-transform: uppercase;
+  font-weight: bold;
 }
 
 h3 {
-    text-transform: uppercase;
+  text-transform: uppercase;
 }
 
 h4 {
-    font-weight: bold;
+  font-weight: bold;
 }
 
 #duo-frame {
-    background: url('../images/loading.svg') 0 0 no-repeat;
-    height: 380px;
+  background: url("../images/loading.svg") 0 0 no-repeat;
+  height: 380px;
 
-    iframe {
-        width: 100%;
-        height: 100%;
-        border: none;
-    }
+  iframe {
+    width: 100%;
+    height: 100%;
+    border: none;
+  }
 }
 
 app-root > #loading {
-    text-align: center;
-    margin-top: 20px;
-    color: $text-muted;
+  text-align: center;
+  margin-top: 20px;
+  color: $text-muted;
 }
 
 ul.testing-list {
-    ul {
-        padding-left: 18px;
-    }
+  ul {
+    padding-left: 18px;
+  }
 
-    li.deleted {
-        text-decoration: line-through;
-    }
+  li.deleted {
+    text-decoration: line-through;
+  }
 }
 
 .callout {
-    padding: 10px;
-    margin-bottom: 10px;
-    border: 1px solid #000000;
-    border-left-width: 5px;
-    border-radius: 3px;
-    border-color: #ddd;
-    background-color: white;
+  padding: 10px;
+  margin-bottom: 10px;
+  border: 1px solid #000000;
+  border-left-width: 5px;
+  border-radius: 3px;
+  border-color: #ddd;
+  background-color: white;
+
+  .callout-heading {
+    margin-top: 0;
+  }
+
+  h3.callout-heading {
+    font-weight: bold;
+    text-transform: uppercase;
+  }
+
+  &.callout-primary {
+    border-left-color: $primary;
 
     .callout-heading {
-        margin-top: 0;
+      color: $primary;
     }
+  }
 
-    h3.callout-heading {
-        font-weight: bold;
-        text-transform: uppercase;
+  &.callout-info {
+    border-left-color: $info;
+
+    .callout-heading {
+      color: $info;
     }
+  }
 
-    &.callout-primary {
-        border-left-color: $primary;
+  &.callout-danger {
+    border-left-color: $danger;
 
-        .callout-heading {
-            color: $primary;
-        }
+    .callout-heading {
+      color: $danger;
     }
+  }
 
-    &.callout-info {
-        border-left-color: $info;
+  &.callout-success {
+    border-left-color: $success;
 
-        .callout-heading {
-            color: $info; 
-        }
+    .callout-heading {
+      color: $success;
     }
+  }
 
-    &.callout-danger {
-        border-left-color: $danger;
+  &.callout-warning {
+    border-left-color: $warning;
 
-        .callout-heading {
-            color: $danger;
-        }
+    .callout-heading {
+      color: $warning;
     }
+  }
 
-    &.callout-success {
-        border-left-color: $success;
-
-        .callout-heading {
-            color: $success;
-        }
-    }
-
-    &.callout-warning {
-        border-left-color: $warning;
-
-        .callout-heading {
-            color: $warning;
-        }
-    }
-
-    ul {
-        padding-left: 40px;
-        margin: 0;
-    }
+  ul {
+    padding-left: 40px;
+    margin: 0;
+  }
 }
 
+.btn[class*="btn-outline-"] {
+  &:not(:hover) {
+    border-color: $secondary;
+    background-color: #fbfbfb;
+  }
+}
+
+.btn-outline-secondary {
+  color: $text-muted;
+
+  &:hover:not(:disabled) {
+    color: $body-color;
+  }
+
+  &:disabled {
+    opacity: 1;
+  }
+
+  &:focus,
+  &.focus {
+    box-shadow: 0 0 0 $btn-focus-width rgba(mix(color-yiq($primary), $primary, 15%), 0.5);
+  }
+}

src/scss/plugins.scss

@@ -1,130 +1,126 @@
-$fa-font-path: "~font-awesome/fonts";
-@import "~font-awesome/scss/font-awesome.scss";
-@import "~angular2-toaster/toaster";
+@import "~ngx-toastr/toastr";
 
 @import "~bootstrap/scss/_variables.scss";
 
-#toast-container {
+.toast-container {
+  .toast-close-button {
+    font-size: 18px;
+    margin-right: 4px;
+  }
+
+  .ngx-toastr {
+    align-items: center;
+    background-image: none !important;
+    border-radius: $border-radius;
+    box-shadow: 0 0 8px rgba(0, 0, 0, 0.35);
+    display: flex;
+    padding: 15px;
+
     .toast-close-button {
-        right: -0.15em;
+      position: absolute;
+      right: 5px;
+      top: 0;
     }
 
-    .toast {
-        opacity: 1 !important;
-        background-image: none !important;
-        border-radius: $border-radius;
-        box-shadow: 0 0 8px rgba(0, 0, 0, 0.35);
-        display: flex;
-        align-items: center;
-
-        &:hover {
-            box-shadow: 0 0 10px rgba(0, 0, 0, 0.6);
-        }
-
-        &:before {
-            font-family: FontAwesome;
-            font-size: 25px;
-            line-height: 20px;
-            float: left;
-            color: #ffffff;
-            padding-right: 10px;
-            margin: auto 0 auto -36px;
-        }
-
-        .toaster-icon {
-            display: none;
-        }
-
-        .toast-message {
-            p {
-                margin-bottom: 0.5rem;
-
-                &:last-child {
-                    margin-bottom: 0;
-                }
-            }
-        }
-
-        &.toast-danger, &.toast-error {
-            background-image: none !important;
-            background-color: $danger;
-
-            &:before {
-                content: "\f0e7";
-                margin-left: -30px;
-            }
-        }
-
-        &.toast-warning {
-            background-image: none !important;
-            background-color: $warning;
-
-            &:before {
-                content: "\f071";
-            }
-        }
-
-        &.toast-info {
-            background-image: none !important;
-            background-color: $info;
-
-            &:before {
-                content: "\f05a";
-            }
-        }
-
-        &.toast-success {
-            background-image: none !important;
-            background-color: $success;
-
-            &:before {
-                content: "\f00C";
-            }
-        }
+    &:hover {
+      box-shadow: 0 0 10px rgba(0, 0, 0, 0.6);
     }
+
+    .icon i::before {
+      float: left;
+      font-style: normal;
+      font-family: $icomoon-font-family;
+      font-size: 25px;
+      line-height: 20px;
+      padding-right: 15px;
+    }
+
+    .toast-message {
+      p {
+        margin-bottom: 0.5rem;
+
+        &:last-child {
+          margin-bottom: 0;
+        }
+      }
+    }
+
+    &.toast-danger,
+    &.toast-error {
+      background-color: $danger;
+
+      .icon i::before {
+        content: map_get($icons, "error");
+      }
+    }
+
+    &.toast-warning {
+      background-color: $warning;
+
+      .icon i::before {
+        content: map_get($icons, "exclamation-triangle");
+      }
+    }
+
+    &.toast-info {
+      background-color: $info;
+
+      .icon i:before {
+        content: map_get($icons, "info-circle");
+      }
+    }
+
+    &.toast-success {
+      background-color: $success;
+
+      .icon i:before {
+        content: map_get($icons, "check");
+      }
+    }
+  }
 }
 
 @keyframes modalshow {
-    0% {
-        opacity: 0;
-        transform: translate(0, -25%);
-    }
+  0% {
+    opacity: 0;
+    transform: translate(0, -25%);
+  }
 
-    100% {
-        opacity: 1;
-        transform: translate(0, 0);
-    }
+  100% {
+    opacity: 1;
+    transform: translate(0, 0);
+  }
 }
 
 @keyframes backdropshow {
-    0% {
-        opacity: 0;
-    }
+  0% {
+    opacity: 0;
+  }
 
-    100% {
-        opacity: $modal-backdrop-opacity;
-    }
+  100% {
+    opacity: $modal-backdrop-opacity;
+  }
 }
 
 .modal {
-    display: block !important;
-    opacity: 1 !important;
+  display: block !important;
+  opacity: 1 !important;
 }
 
 .modal-dialog {
-    .modal.fade & {
-        transform: initial !important;
-        animation: modalshow 0.3s ease-in;
-    }
-    .modal.show & {
-        transform: initial !important;
-    }
-    transform: translate(0, 0);
+  .modal.fade & {
+    transform: initial !important;
+    animation: modalshow 0.3s ease-in;
+  }
+  .modal.show & {
+    transform: initial !important;
+  }
+  transform: translate(0, 0);
 }
 
 .modal-backdrop {
-    &.fade {
-        animation: backdropshow 0.1s ease-in;
-    }
-    opacity: $modal-backdrop-opacity !important;
+  &.fade {
+    animation: backdropshow 0.1s ease-in;
+  }
+  opacity: $modal-backdrop-opacity !important;
 }

src/scss/styles.scss

@@ -1,4 +1,5 @@
-@import "../css/webfonts.css";
+@import "../../jslib/angular/src/scss/webfonts.css";
+@import "../../jslib/angular/src/scss/bwicons/styles/style.scss";
 @import "bootstrap.scss";
 @import "pages.scss";
 @import "misc.scss";

src/services/api.service.ts

@@ -0,0 +1,36 @@
+import { AuthService } from "jslib-common/abstractions/auth.service";
+import { EnvironmentService } from "jslib-common/abstractions/environment.service";
+import { PlatformUtilsService } from "jslib-common/abstractions/platformUtils.service";
+import { TokenService } from "jslib-common/abstractions/token.service";
+import { StateService } from "../abstractions/state.service";
+
+import { ApiService as ApiServiceBase } from "jslib-common/services/api.service";
+
+export async function refreshToken(stateService: StateService, authService: AuthService) {
+  try {
+    const clientId = await stateService.getApiKeyClientId();
+    const clientSecret = await stateService.getApiKeyClientSecret();
+    if (clientId != null && clientSecret != null) {
+      await authService.logInApiKey(clientId, clientSecret);
+    }
+  } catch (e) {
+    return Promise.reject(e);
+  }
+}
+
+export class ApiService extends ApiServiceBase {
+  constructor(
+    tokenService: TokenService,
+    platformUtilsService: PlatformUtilsService,
+    environmentService: EnvironmentService,
+    private refreshTokenCallback: () => Promise<void>,
+    logoutCallback: (expired: boolean) => Promise<void>,
+    customUserAgent: string = null
+  ) {
+    super(tokenService, platformUtilsService, environmentService, logoutCallback, customUserAgent);
+  }
+
+  doRefreshToken(): Promise<void> {
+    return this.refreshTokenCallback();
+  }
+}

src/services/auth.service.ts

@@ -0,0 +1,119 @@
+import { ApiService } from "jslib-common/abstractions/api.service";
+import { AppIdService } from "jslib-common/abstractions/appId.service";
+import { CryptoService } from "jslib-common/abstractions/crypto.service";
+import { CryptoFunctionService } from "jslib-common/abstractions/cryptoFunction.service";
+import { EnvironmentService } from "jslib-common/abstractions/environment.service";
+import { I18nService } from "jslib-common/abstractions/i18n.service";
+import { KeyConnectorService } from "jslib-common/abstractions/keyConnector.service";
+import { LogService } from "jslib-common/abstractions/log.service";
+import { MessagingService } from "jslib-common/abstractions/messaging.service";
+import { PlatformUtilsService } from "jslib-common/abstractions/platformUtils.service";
+import { TokenService } from "jslib-common/abstractions/token.service";
+import { VaultTimeoutService } from "jslib-common/abstractions/vaultTimeout.service";
+import { StateService } from "../abstractions/state.service";
+
+import { AuthService as AuthServiceBase } from "jslib-common/services/auth.service";
+
+import { Account, DirectoryConfigurations, DirectorySettings } from "src/models/account";
+
+import { AccountKeys, AccountProfile, AccountTokens } from "jslib-common/models/domain/account";
+import { AuthResult } from "jslib-common/models/domain/authResult";
+
+import { DeviceRequest } from "jslib-common/models/request/deviceRequest";
+import { TokenRequest } from "jslib-common/models/request/tokenRequest";
+
+import { IdentityTokenResponse } from "jslib-common/models/response/identityTokenResponse";
+
+export class AuthService extends AuthServiceBase {
+  constructor(
+    cryptoService: CryptoService,
+    apiService: ApiService,
+    tokenService: TokenService,
+    appIdService: AppIdService,
+    i18nService: I18nService,
+    platformUtilsService: PlatformUtilsService,
+    messagingService: MessagingService,
+    vaultTimeoutService: VaultTimeoutService,
+    logService: LogService,
+    cryptoFunctionService: CryptoFunctionService,
+    environmentService: EnvironmentService,
+    keyConnectorService: KeyConnectorService,
+    stateService: StateService
+  ) {
+    super(
+      cryptoService,
+      apiService,
+      tokenService,
+      appIdService,
+      i18nService,
+      platformUtilsService,
+      messagingService,
+      vaultTimeoutService,
+      logService,
+      cryptoFunctionService,
+      keyConnectorService,
+      environmentService,
+      stateService,
+      false
+    );
+  }
+
+  async logInApiKey(clientId: string, clientSecret: string): Promise<AuthResult> {
+    this.selectedTwoFactorProviderType = null;
+    if (clientId.startsWith("organization")) {
+      return await this.organizationLogInHelper(clientId, clientSecret);
+    }
+    return await super.logInApiKey(clientId, clientSecret);
+  }
+
+  private async organizationLogInHelper(clientId: string, clientSecret: string) {
+    const appId = await this.appIdService.getAppId();
+    const entityId = clientId.split("organization.")[1];
+    const deviceRequest = new DeviceRequest(appId, this.platformUtilsService);
+    const request = new TokenRequest(
+      null,
+      null,
+      [clientId, clientSecret],
+      null,
+      null,
+      false,
+      null,
+      deviceRequest
+    );
+
+    const response = await this.apiService.postIdentityToken(request);
+    const result = new AuthResult();
+    result.twoFactor = !(response as any).accessToken;
+
+    const tokenResponse = response as IdentityTokenResponse;
+    result.resetMasterPassword = tokenResponse.resetMasterPassword;
+    await this.stateService.addAccount(
+      new Account({
+        profile: {
+          ...new AccountProfile(),
+          ...{
+            userId: entityId,
+            apiKeyClientId: clientId,
+            entityId: entityId,
+          },
+        },
+        tokens: {
+          ...new AccountTokens(),
+          ...{
+            accessToken: tokenResponse.accessToken,
+            refreshToken: tokenResponse.refreshToken,
+          },
+        },
+        keys: {
+          ...new AccountKeys(),
+          ...{
+            apiKeyClientSecret: clientSecret,
+          },
+        },
+        directorySettings: new DirectorySettings(),
+        directoryConfigurations: new DirectoryConfigurations(),
+      })
+    );
+    return result;
+  }
+}

src/services/azure-directory.service.ts

@@ -1,459 +1,529 @@
-import * as graph from '@microsoft/microsoft-graph-client';
-import * as graphType from '@microsoft/microsoft-graph-types';
-import * as https from 'https';
-import * as querystring from 'querystring';
+import * as graph from "@microsoft/microsoft-graph-client";
+import * as graphType from "@microsoft/microsoft-graph-types";
+import * as https from "https";
+import * as querystring from "querystring";
 
-import { DirectoryType } from '../enums/directoryType';
+import { DirectoryType } from "../enums/directoryType";
 
-import { AzureConfiguration } from '../models/azureConfiguration';
-import { GroupEntry } from '../models/groupEntry';
-import { SyncConfiguration } from '../models/syncConfiguration';
-import { UserEntry } from '../models/userEntry';
+import { AzureConfiguration } from "../models/azureConfiguration";
+import { GroupEntry } from "../models/groupEntry";
+import { SyncConfiguration } from "../models/syncConfiguration";
+import { UserEntry } from "../models/userEntry";
 
-import { BaseDirectoryService } from './baseDirectory.service';
-import { ConfigurationService } from './configuration.service';
-import { IDirectoryService } from './directory.service';
+import { BaseDirectoryService } from "./baseDirectory.service";
+import { IDirectoryService } from "./directory.service";
 
-import { I18nService } from 'jslib/abstractions/i18n.service';
-import { LogService } from 'jslib/abstractions/log.service';
+import { I18nService } from "jslib-common/abstractions/i18n.service";
+import { LogService } from "jslib-common/abstractions/log.service";
+import { StateService } from "../abstractions/state.service";
 
-const NextLink = '@odata.nextLink';
-const DeltaLink = '@odata.deltaLink';
-const ObjectType = '@odata.type';
-const UserSelectParams = '?$select=id,mail,userPrincipalName,displayName,accountEnabled';
+const AzurePublicIdentityAuhtority = "login.microsoftonline.com";
+const AzureGovermentIdentityAuhtority = "login.microsoftonline.us";
+
+const NextLink = "@odata.nextLink";
+const DeltaLink = "@odata.deltaLink";
+const ObjectType = "@odata.type";
+const UserSelectParams = "?$select=id,mail,userPrincipalName,displayName,accountEnabled";
 
 enum UserSetType {
-    IncludeUser,
-    ExcludeUser,
-    IncludeGroup,
-    ExcludeGroup,
+  IncludeUser,
+  ExcludeUser,
+  IncludeGroup,
+  ExcludeGroup,
 }
 
 export class AzureDirectoryService extends BaseDirectoryService implements IDirectoryService {
-    private client: graph.Client;
-    private dirConfig: AzureConfiguration;
-    private syncConfig: SyncConfiguration;
-    private accessToken: string;
-    private accessTokenExpiration: Date;
+  private client: graph.Client;
+  private dirConfig: AzureConfiguration;
+  private syncConfig: SyncConfiguration;
+  private accessToken: string;
+  private accessTokenExpiration: Date;
 
-    constructor(private configurationService: ConfigurationService, private logService: LogService,
-        private i18nService: I18nService) {
-        super();
-        this.init();
+  constructor(
+    private logService: LogService,
+    private i18nService: I18nService,
+    private stateService: StateService
+  ) {
+    super();
+    this.init();
+  }
+
+  async getEntries(force: boolean, test: boolean): Promise<[GroupEntry[], UserEntry[]]> {
+    const type = await this.stateService.getDirectoryType();
+    if (type !== DirectoryType.AzureActiveDirectory) {
+      return;
     }
 
-    async getEntries(force: boolean, test: boolean): Promise<[GroupEntry[], UserEntry[]]> {
-        const type = await this.configurationService.getDirectoryType();
-        if (type !== DirectoryType.AzureActiveDirectory) {
-            return;
-        }
-
-        this.dirConfig = await this.configurationService.getDirectory<AzureConfiguration>(
-            DirectoryType.AzureActiveDirectory);
-        if (this.dirConfig == null) {
-            return;
-        }
-
-        this.syncConfig = await this.configurationService.getSync();
-        if (this.syncConfig == null) {
-            return;
-        }
-
-        let users: UserEntry[];
-        if (this.syncConfig.users) {
-            users = await this.getCurrentUsers();
-            const deletedUsers = await this.getDeletedUsers(force, !test);
-            users = users.concat(deletedUsers);
-        }
-
-        let groups: GroupEntry[];
-        if (this.syncConfig.groups) {
-            const setFilter = await this.createAadCustomSet(this.syncConfig.groupFilter);
-            groups = await this.getGroups(setFilter);
-            users = this.filterUsersFromGroupsSet(users, groups, setFilter, this.syncConfig);
-        }
-
-        return [groups, users];
+    this.dirConfig = await this.stateService.getDirectory<AzureConfiguration>(
+      DirectoryType.AzureActiveDirectory
+    );
+    if (this.dirConfig == null) {
+      return;
     }
 
-    private async getCurrentUsers(): Promise<UserEntry[]> {
-        const entryIds = new Set<string>();
-        const entries: UserEntry[] = [];
-        const userReq = this.client.api('/users' + UserSelectParams);
-        let res = await userReq.get();
-        const setFilter = this.createCustomUserSet(this.syncConfig.userFilter);
-        while (true) {
-            const users: graphType.User[] = res.value;
-            if (users != null) {
-                for (const user of users) {
-                    if (user.id == null || entryIds.has(user.id)) {
-                        continue;
-                    }
-                    const entry = this.buildUser(user);
-                    if (await this.filterOutUserResult(setFilter, entry, true)) {
-                        continue;
-                    }
-
-                    if (!entry.disabled && !entry.deleted &&
-                        (entry.email == null || entry.email.indexOf('#') > -1)) {
-                        continue;
-                    }
-
-                    entries.push(entry);
-                    entryIds.add(user.id);
-                }
-            }
-
-            if (res[NextLink] == null) {
-                break;
-            } else {
-                const nextReq = this.client.api(res[NextLink]);
-                res = await nextReq.get();
-            }
-        }
-
-        return entries;
+    this.syncConfig = await this.stateService.getSync();
+    if (this.syncConfig == null) {
+      return;
     }
 
-    private async getDeletedUsers(force: boolean, saveDelta: boolean): Promise<UserEntry[]> {
-        const entryIds = new Set<string>();
-        const entries: UserEntry[] = [];
-
-        let res: any = null;
-        const token = await this.configurationService.getUserDeltaToken();
-        if (!force && token != null) {
-            try {
-                const deltaReq = this.client.api(token);
-                res = await deltaReq.get();
-            } catch {
-                res = null;
-            }
-        }
-
-        if (res == null) {
-            const userReq = this.client.api('/users/delta' + UserSelectParams);
-            res = await userReq.get();
-        }
-
-        const setFilter = this.createCustomUserSet(this.syncConfig.userFilter);
-        while (true) {
-            const users: graphType.User[] = res.value;
-            if (users != null) {
-                for (const user of users) {
-                    if (user.id == null || entryIds.has(user.id)) {
-                        continue;
-                    }
-                    const entry = this.buildUser(user);
-                    if (!entry.disabled && !entry.deleted) {
-                        continue;
-                    }
-                    if (await this.filterOutUserResult(setFilter, entry, false)) {
-                        continue;
-                    }
-
-                    entries.push(entry);
-                    entryIds.add(user.id);
-                }
-            }
-
-            if (res[NextLink] == null) {
-                if (res[DeltaLink] != null && saveDelta) {
-                    await this.configurationService.saveUserDeltaToken(res[DeltaLink]);
-                }
-                break;
-            } else {
-                const nextReq = this.client.api(res[NextLink]);
-                res = await nextReq.get();
-            }
-        }
-
-        return entries;
+    let users: UserEntry[];
+    if (this.syncConfig.users) {
+      users = await this.getCurrentUsers();
+      const deletedUsers = await this.getDeletedUsers(force, !test);
+      users = users.concat(deletedUsers);
     }
 
-    private async createAadCustomSet(filter: string): Promise<[boolean, Set<string>]> {
-        if (filter == null || filter === '') {
-            return null;
-        }
-
-        const mainParts = filter.split('|');
-        if (mainParts.length < 1 || mainParts[0] == null || mainParts[0].trim() === '') {
-            return null;
-        }
-
-        const parts = mainParts[0].split(':');
-        if (parts.length !== 2) {
-            return null;
-        }
-
-        const keyword = parts[0].trim().toLowerCase();
-        let exclude = true;
-        if (keyword === 'include') {
-            exclude = false;
-        } else if (keyword === 'exclude') {
-            exclude = true;
-        } else if (keyword === 'excludeadministrativeunit') {
-            exclude = true;
-        } else if (keyword === 'includeadministrativeunit') {
-            exclude = false;
-        } else {
-            return null;
-        }
-
-        const set = new Set<string>();
-        const pieces = parts[1].split(',');
-        if (keyword === 'excludeadministrativeunit' || keyword === 'includeadministrativeunit') {
-            for (const p of pieces) {
-                const auMembers = await this.client
-                    .api(`https://graph.microsoft.com/beta/administrativeUnits/${p}/members`).get();
-                for (const auMember of auMembers.value) {
-                    if (auMember['@odata.type'] === '#microsoft.graph.group') {
-                        set.add(auMember.displayName.toLowerCase());
-                    }
-                }
-            }
-        } else {
-            for (const p of pieces) {
-                set.add(p.trim().toLowerCase());
-            }
-        }
-        return [exclude, set];
+    let groups: GroupEntry[];
+    if (this.syncConfig.groups) {
+      const setFilter = await this.createAadCustomSet(this.syncConfig.groupFilter);
+      groups = await this.getGroups(setFilter);
+      users = this.filterUsersFromGroupsSet(users, groups, setFilter, this.syncConfig);
     }
 
-    private createCustomUserSet(filter: string): [UserSetType, Set<string>] {
-        if (filter == null || filter === '') {
-            return null;
-        }
+    return [groups, users];
+  }
 
-        const mainParts = filter.split('|');
-        if (mainParts.length < 1 || mainParts[0] == null || mainParts[0].trim() === '') {
-            return null;
-        }
+  private async getCurrentUsers(): Promise<UserEntry[]> {
+    const entryIds = new Set<string>();
+    let entries: UserEntry[] = [];
+    let users: graphType.User[];
+    const setFilter = this.createCustomUserSet(this.syncConfig.userFilter);
+    const userIdsToExclude = new Set<string>();
 
-        const parts = mainParts[0].split(':');
-        if (parts.length !== 2) {
-            return null;
-        }
+    // Only get users for the groups provided in includeGroup filter
+    if (setFilter != null && setFilter[0] === UserSetType.IncludeGroup) {
+      users = await this.getUsersByGroups(setFilter);
+      // Get the users in the excludedGroups and filter them out from all users
+    } else if (setFilter != null && setFilter[0] === UserSetType.ExcludeGroup) {
+      (await this.getUsersByGroups(setFilter)).forEach((user: graphType.User) =>
+        userIdsToExclude.add(user.id)
+      );
+      const userReq = this.client.api("/users" + UserSelectParams);
+      users = await this.getUsersByResource(userReq);
+    } else {
+      const userReq = this.client.api("/users" + UserSelectParams);
+      users = await this.getUsersByResource(userReq);
+    }
+    if (users != null) {
+      entries = await this.buildUserEntries(users, userIdsToExclude, setFilter);
+    }
+    return entries;
+  }
 
-        const keyword = parts[0].trim().toLowerCase();
-        let userSetType = UserSetType.IncludeUser;
-        if (keyword === 'include') {
-            userSetType = UserSetType.IncludeUser;
-        } else if (keyword === 'exclude') {
-            userSetType = UserSetType.ExcludeUser;
-        } else if (keyword === 'includegroup') {
-            userSetType = UserSetType.IncludeGroup;
-        } else if (keyword === 'excludegroup') {
-            userSetType = UserSetType.ExcludeGroup;
-        } else {
-            return null;
-        }
+  private async getDeletedUsers(force: boolean, saveDelta: boolean): Promise<UserEntry[]> {
+    const entryIds = new Set<string>();
+    const entries: UserEntry[] = [];
 
-        const set = new Set<string>();
-        const pieces = parts[1].split(',');
-        for (const p of pieces) {
-            set.add(p.trim().toLowerCase());
-        }
-
-        return [userSetType, set];
+    let res: any = null;
+    const token = await this.stateService.getUserDelta();
+    if (!force && token != null) {
+      try {
+        const deltaReq = this.client.api(token);
+        res = await deltaReq.get();
+      } catch {
+        res = null;
+      }
     }
 
-    private async filterOutUserResult(setFilter: [UserSetType, Set<string>], user: UserEntry,
-        checkGroupsFilter: boolean): Promise<boolean> {
-        if (setFilter == null) {
-            return false;
+    if (res == null) {
+      const userReq = this.client.api("/users/delta" + UserSelectParams);
+      res = await userReq.get();
+    }
+
+    const setFilter = this.createCustomUserSet(this.syncConfig.userFilter);
+    while (true) {
+      const users: graphType.User[] = res.value;
+      if (users != null) {
+        for (const user of users) {
+          if (user.id == null || entryIds.has(user.id)) {
+            continue;
+          }
+          const entry = this.buildUser(user);
+          if (!entry.deleted) {
+            continue;
+          }
+
+          if (
+            setFilter != null &&
+            (setFilter[0] === UserSetType.IncludeUser ||
+              setFilter[0] === UserSetType.ExcludeUser) &&
+            (await this.filterOutUserResult(setFilter, entry))
+          ) {
+            continue;
+          }
+
+          entries.push(entry);
+          entryIds.add(user.id);
+        }
+      }
+
+      if (res[NextLink] == null) {
+        if (res[DeltaLink] != null && saveDelta) {
+          await this.stateService.setUserDelta(res[DeltaLink]);
+        }
+        break;
+      } else {
+        const nextReq = this.client.api(res[NextLink]);
+        res = await nextReq.get();
+      }
+    }
+
+    return entries;
+  }
+
+  private async createAadCustomSet(filter: string): Promise<[boolean, Set<string>]> {
+    if (filter == null || filter === "") {
+      return null;
+    }
+
+    const mainParts = filter.split("|");
+    if (mainParts.length < 1 || mainParts[0] == null || mainParts[0].trim() === "") {
+      return null;
+    }
+
+    const parts = mainParts[0].split(":");
+    if (parts.length !== 2) {
+      return null;
+    }
+
+    const keyword = parts[0].trim().toLowerCase();
+    let exclude = true;
+    if (keyword === "include") {
+      exclude = false;
+    } else if (keyword === "exclude") {
+      exclude = true;
+    } else if (keyword === "excludeadministrativeunit") {
+      exclude = true;
+    } else if (keyword === "includeadministrativeunit") {
+      exclude = false;
+    } else {
+      return null;
+    }
+
+    const set = new Set<string>();
+    const pieces = parts[1].split(",");
+    if (keyword === "excludeadministrativeunit" || keyword === "includeadministrativeunit") {
+      for (const p of pieces) {
+        const auMembers = await this.client
+          .api(`https://graph.microsoft.com/v1.0/directory/administrativeUnits/${p}/members`)
+          .get();
+        for (const auMember of auMembers.value) {
+          if (auMember["@odata.type"] === "#microsoft.graph.group") {
+            set.add(auMember.displayName.toLowerCase());
+          }
+        }
+      }
+    } else {
+      for (const p of pieces) {
+        set.add(p.trim().toLowerCase());
+      }
+    }
+    return [exclude, set];
+  }
+
+  private createCustomUserSet(filter: string): [UserSetType, Set<string>] {
+    if (filter == null || filter === "") {
+      return null;
+    }
+
+    const mainParts = filter.split("|");
+    if (mainParts.length < 1 || mainParts[0] == null || mainParts[0].trim() === "") {
+      return null;
+    }
+
+    const parts = mainParts[0].split(":");
+    if (parts.length !== 2) {
+      return null;
+    }
+
+    const keyword = parts[0].trim().toLowerCase();
+    let userSetType = UserSetType.IncludeUser;
+    if (keyword === "include") {
+      userSetType = UserSetType.IncludeUser;
+    } else if (keyword === "exclude") {
+      userSetType = UserSetType.ExcludeUser;
+    } else if (keyword === "includegroup") {
+      userSetType = UserSetType.IncludeGroup;
+    } else if (keyword === "excludegroup") {
+      userSetType = UserSetType.ExcludeGroup;
+    } else {
+      return null;
+    }
+
+    const set = new Set<string>();
+    const pieces = parts[1].split(",");
+    for (const p of pieces) {
+      set.add(p.trim().toLowerCase());
+    }
+
+    return [userSetType, set];
+  }
+
+  private async filterOutUserResult(
+    setFilter: [UserSetType, Set<string>],
+    user: UserEntry
+  ): Promise<boolean> {
+    if (setFilter == null) {
+      return false;
+    }
+
+    let userSetTypeExclude = null;
+    if (setFilter[0] === UserSetType.IncludeUser) {
+      userSetTypeExclude = false;
+    } else if (setFilter[0] === UserSetType.ExcludeUser) {
+      userSetTypeExclude = true;
+    }
+
+    if (userSetTypeExclude != null) {
+      return this.filterOutResult([userSetTypeExclude, setFilter[1]], user.email);
+    }
+
+    return false;
+  }
+
+  private buildUser(user: graphType.User): UserEntry {
+    const entry = new UserEntry();
+    entry.referenceId = user.id;
+    entry.externalId = user.id;
+    entry.email = user.mail;
+
+    if (
+      user.userPrincipalName &&
+      (entry.email == null || entry.email === "" || entry.email.indexOf("onmicrosoft.com") > -1)
+    ) {
+      entry.email = user.userPrincipalName;
+    }
+
+    if (entry.email != null) {
+      entry.email = entry.email.trim().toLowerCase();
+    }
+
+    entry.disabled = user.accountEnabled == null ? false : !user.accountEnabled;
+
+    if ((user as any)["@removed"] != null && (user as any)["@removed"].reason === "changed") {
+      entry.deleted = true;
+    }
+
+    return entry;
+  }
+
+  private async getGroups(setFilter: [boolean, Set<string>]): Promise<GroupEntry[]> {
+    const entryIds = new Set<string>();
+    const entries: GroupEntry[] = [];
+    const groupsReq = this.client.api("/groups");
+    let res = await groupsReq.get();
+    while (true) {
+      const groups: graphType.Group[] = res.value;
+      if (groups != null) {
+        for (const group of groups) {
+          if (group.id == null || entryIds.has(group.id)) {
+            continue;
+          }
+          if (this.filterOutResult(setFilter, group.displayName)) {
+            continue;
+          }
+
+          const entry = await this.buildGroup(group);
+          entries.push(entry);
+          entryIds.add(group.id);
+        }
+      }
+
+      if (res[NextLink] == null) {
+        break;
+      } else {
+        const nextReq = this.client.api(res[NextLink]);
+        res = await nextReq.get();
+      }
+    }
+
+    return entries;
+  }
+
+  private async getUsersByResource(usersRequest: graph.GraphRequest) {
+    const users: graphType.User[] = [];
+    let res = await usersRequest.get();
+    res.value.forEach((user: graphType.User) => users.push(user));
+    while (res[NextLink] != null) {
+      const nextReq = this.client.api(res[NextLink]);
+      res = await nextReq.get();
+      res.value.forEach((user: graphType.User) => users.push(user));
+    }
+    return users;
+  }
+
+  private async getUsersByGroups(setFilter: [UserSetType, Set<string>]): Promise<graphType.User[]> {
+    const users: graphType.User[] = [];
+    for (const group of setFilter[1]) {
+      const groupUsersReq = this.client.api(
+        `/groups/${group}/transitiveMembers` + UserSelectParams
+      );
+      users.push(...(await this.getUsersByResource(groupUsersReq)));
+    }
+    return users;
+  }
+
+  private async buildUserEntries(
+    users: graphType.User[],
+    userIdsToExclude: Set<string>,
+    setFilter: [UserSetType, Set<string>]
+  ) {
+    const entryIds = new Set<string>();
+    const entries: UserEntry[] = [];
+
+    for (const user of users) {
+      if (user.id == null || entryIds.has(user.id) || userIdsToExclude.has(user.id)) {
+        continue;
+      }
+      const entry = this.buildUser(user);
+
+      if (
+        setFilter != null &&
+        (setFilter[0] === UserSetType.IncludeUser || setFilter[0] === UserSetType.ExcludeUser) &&
+        (await this.filterOutUserResult(setFilter, entry))
+      ) {
+        continue;
+      }
+      if (!this.isInvalidUser(entry)) {
+        entries.push(entry);
+        entryIds.add(user.id);
+      }
+    }
+    return entries;
+  }
+
+  private isInvalidUser(user: UserEntry): boolean {
+    return !user.disabled && !user.deleted && (user.email == null || user.email.indexOf("#") > -1);
+  }
+
+  private async buildGroup(group: graphType.Group): Promise<GroupEntry> {
+    const entry = new GroupEntry();
+    entry.referenceId = group.id;
+    entry.externalId = group.id;
+    entry.name = group.displayName;
+
+    const memReq = this.client.api("/groups/" + group.id + "/members");
+    let memRes = await memReq.get();
+    while (true) {
+      const members: any = memRes.value;
+      if (members != null) {
+        for (const member of members) {
+          if (member[ObjectType] === "#microsoft.graph.group") {
+            entry.groupMemberReferenceIds.add((member as graphType.Group).id);
+          } else if (member[ObjectType] === "#microsoft.graph.user") {
+            entry.userMemberExternalIds.add((member as graphType.User).id);
+          }
+        }
+      }
+      if (memRes[NextLink] == null) {
+        break;
+      } else {
+        const nextMemReq = this.client.api(memRes[NextLink]);
+        memRes = await nextMemReq.get();
+      }
+    }
+
+    return entry;
+  }
+
+  private init() {
+    this.client = graph.Client.init({
+      authProvider: (done) => {
+        if (
+          this.dirConfig.applicationId == null ||
+          this.dirConfig.key == null ||
+          this.dirConfig.tenant == null
+        ) {
+          done(new Error(this.i18nService.t("dirConfigIncomplete")), null);
+          return;
         }
 
-        let userSetTypeExclude = null;
-        if (setFilter[0] === UserSetType.IncludeUser) {
-            userSetTypeExclude = false;
-        } else if (setFilter[0] === UserSetType.ExcludeUser) {
-            userSetTypeExclude = true;
+        const identityAuthority =
+          this.dirConfig.identityAuthority != null
+            ? this.dirConfig.identityAuthority
+            : AzurePublicIdentityAuhtority;
+        if (
+          identityAuthority !== AzurePublicIdentityAuhtority &&
+          identityAuthority !== AzureGovermentIdentityAuhtority
+        ) {
+          done(new Error(this.i18nService.t("dirConfigIncomplete")), null);
+          return;
         }
 
-        if (userSetTypeExclude != null) {
-            return this.filterOutResult([userSetTypeExclude, setFilter[1]], user.email);
+        if (!this.accessTokenIsExpired()) {
+          done(null, this.accessToken);
+          return;
         }
 
-        // We need to *not* call the /checkMemberGroups method for deleted users, it will always fail
-        if (!checkGroupsFilter) {
-            return false;
-        }
-        const memberGroups = await this.client.api(`/users/${user.externalId}/checkMemberGroups`).post({
-            groupIds: Array.from(setFilter[1]),
+        this.accessToken = null;
+        this.accessTokenExpiration = null;
+
+        const data = querystring.stringify({
+          client_id: this.dirConfig.applicationId,
+          client_secret: this.dirConfig.key,
+          grant_type: "client_credentials",
+          scope: "https://graph.microsoft.com/.default",
         });
-        if (memberGroups.value.length > 0 && setFilter[0] === UserSetType.IncludeGroup) {
-            return false;
-        } else if (memberGroups.value.length > 0 && setFilter[0] === UserSetType.ExcludeGroup) {
-            return true;
-        } else if (memberGroups.value.length === 0 && setFilter[0] === UserSetType.IncludeGroup) {
-            return true;
-        } else if (memberGroups.value.length === 0 && setFilter[0] === UserSetType.ExcludeGroup) {
-            return false;
-        }
 
-        return false;
-    }
-
-    private buildUser(user: graphType.User): UserEntry {
-        const entry = new UserEntry();
-        entry.referenceId = user.id;
-        entry.externalId = user.id;
-        entry.email = user.mail;
-
-        if (user.userPrincipalName && (entry.email == null || entry.email === '' ||
-            entry.email.indexOf('onmicrosoft.com') > -1)) {
-            entry.email = user.userPrincipalName;
-        }
-
-        if (entry.email != null) {
-            entry.email = entry.email.trim().toLowerCase();
-        }
-
-        entry.disabled = user.accountEnabled == null ? false : !user.accountEnabled;
-
-        if ((user as any)['@removed'] != null && (user as any)['@removed'].reason === 'changed') {
-            entry.deleted = true;
-        }
-
-        return entry;
-    }
-
-    private async getGroups(setFilter: [boolean, Set<string>]): Promise<GroupEntry[]> {
-        const entryIds = new Set<string>();
-        const entries: GroupEntry[] = [];
-        const groupsReq = this.client.api('/groups');
-        let res = await groupsReq.get();
-        while (true) {
-            const groups: graphType.Group[] = res.value;
-            if (groups != null) {
-                for (const group of groups) {
-                    if (group.id == null || entryIds.has(group.id)) {
-                        continue;
-                    }
-                    if (this.filterOutResult(setFilter, group.displayName)) {
-                        continue;
-                    }
-
-                    const entry = await this.buildGroup(group);
-                    entries.push(entry);
-                    entryIds.add(group.id);
-                }
-            }
-
-            if (res[NextLink] == null) {
-                break;
-            } else {
-                const nextReq = this.client.api(res[NextLink]);
-                res = await nextReq.get();
-            }
-        }
-
-        return entries;
-    }
-
-    private async buildGroup(group: graphType.Group): Promise<GroupEntry> {
-        const entry = new GroupEntry();
-        entry.referenceId = group.id;
-        entry.externalId = group.id;
-        entry.name = group.displayName;
-
-        const memReq = this.client.api('/groups/' + group.id + '/members');
-        let memRes = await memReq.get();
-        while (true) {
-            const members: any = memRes.value;
-            if (members != null) {
-                for (const member of members) {
-                    if (member[ObjectType] === '#microsoft.graph.group') {
-                        entry.groupMemberReferenceIds.add((member as graphType.Group).id);
-                    } else if (member[ObjectType] === '#microsoft.graph.user') {
-                        entry.userMemberExternalIds.add((member as graphType.User).id);
-                    }
-                }
-            }
-            if (memRes[NextLink] == null) {
-                break;
-            } else {
-                const nextMemReq = this.client.api(memRes[NextLink]);
-                memRes = await nextMemReq.get();
-            }
-        }
-
-        return entry;
-    }
-
-    private init() {
-        this.client = graph.Client.init({
-            authProvider: done => {
-                if (this.dirConfig.applicationId == null || this.dirConfig.key == null ||
-                    this.dirConfig.tenant == null) {
-                    done(this.i18nService.t('dirConfigIncomplete'), null);
-                    return;
-                }
-
-                if (!this.accessTokenIsExpired()) {
-                    done(null, this.accessToken);
-                    return;
-                }
-
-                this.accessToken = null;
-                this.accessTokenExpiration = null;
-
-                const data = querystring.stringify({
-                    client_id: this.dirConfig.applicationId,
-                    client_secret: this.dirConfig.key,
-                    grant_type: 'client_credentials',
-                    scope: 'https://graph.microsoft.com/.default',
-                });
-
-                const req = https.request({
-                    host: 'login.microsoftonline.com',
-                    path: '/' + this.dirConfig.tenant + '/oauth2/v2.0/token',
-                    method: 'POST',
-                    headers: {
-                        'Content-Type': 'application/x-www-form-urlencoded',
-                        'Content-Length': Buffer.byteLength(data),
-                    },
-                }, res => {
-                    res.setEncoding('utf8');
-                    res.on('data', (chunk: string) => {
-                        const d = JSON.parse(chunk);
-                        if (res.statusCode === 200 && d.access_token != null) {
-                            this.setAccessTokenExpiration(d.access_token, d.expires_in);
-                            done(null, d.access_token);
-                        } else if (d.error != null && d.error_description != null) {
-                            done(d.error + ' (' + res.statusCode + '): ' + d.error_description, null);
-                        } else {
-                            done('Unknown error (' + res.statusCode + ').', null);
-                        }
-                    });
-                }).on('error', err => {
-                    done(err, null);
-                });
-
-                req.write(data);
-                req.end();
+        const req = https
+          .request(
+            {
+              host: identityAuthority,
+              path: "/" + this.dirConfig.tenant + "/oauth2/v2.0/token",
+              method: "POST",
+              headers: {
+                "Content-Type": "application/x-www-form-urlencoded",
+                "Content-Length": Buffer.byteLength(data),
+              },
             },
-        });
+            (res) => {
+              res.setEncoding("utf8");
+              res.on("data", (chunk: string) => {
+                const d = JSON.parse(chunk);
+                if (res.statusCode === 200 && d.access_token != null) {
+                  this.setAccessTokenExpiration(d.access_token, d.expires_in);
+                  done(null, d.access_token);
+                } else if (d.error != null && d.error_description != null) {
+                  const shortError = d.error_description?.split("\n", 1)[0];
+                  const err = new Error(d.error + " (" + res.statusCode + "): " + shortError);
+                  // tslint:disable-next-line
+                  console.error(d.error_description);
+                  done(err, null);
+                } else {
+                  const err = new Error("Unknown error (" + res.statusCode + ").");
+                  done(err, null);
+                }
+              });
+            }
+          )
+          .on("error", (err) => {
+            done(err, null);
+          });
+
+        req.write(data);
+        req.end();
+      },
+    });
+  }
+
+  private accessTokenIsExpired() {
+    if (this.accessToken == null || this.accessTokenExpiration == null) {
+      return true;
     }
 
-    private accessTokenIsExpired() {
-        if (this.accessToken == null || this.accessTokenExpiration == null) {
-            return true;
-        }
+    // expired if less than 2 minutes til expiration
+    const now = new Date();
+    return this.accessTokenExpiration.getTime() - now.getTime() < 120000;
+  }
 
-        // expired if less than 2 minutes til expiration
-        const now = new Date();
-        return this.accessTokenExpiration.getTime() - now.getTime() < 120000;
+  private setAccessTokenExpiration(accessToken: string, expSeconds: number) {
+    if (accessToken == null || expSeconds == null) {
+      return;
     }
 
-    private setAccessTokenExpiration(accessToken: string, expSeconds: number) {
-        if (accessToken == null || expSeconds == null) {
-            return;
-        }
-
-        this.accessToken = accessToken;
-        const exp = new Date();
-        exp.setSeconds(exp.getSeconds() + expSeconds);
-        this.accessTokenExpiration = exp;
-    }
+    this.accessToken = accessToken;
+    const exp = new Date();
+    exp.setSeconds(exp.getSeconds() + expSeconds);
+    this.accessTokenExpiration = exp;
+  }
 }

src/services/baseDirectory.service.ts

@@ -1,91 +1,95 @@
-import { SyncConfiguration } from '../models/syncConfiguration';
+import { SyncConfiguration } from "../models/syncConfiguration";
 
-import { GroupEntry } from '../models/groupEntry';
-import { UserEntry } from '../models/userEntry';
+import { GroupEntry } from "../models/groupEntry";
+import { UserEntry } from "../models/userEntry";
 
 export abstract class BaseDirectoryService {
-    protected createDirectoryQuery(filter: string) {
-        if (filter == null || filter === '') {
-            return null;
-        }
-
-        const mainParts = filter.split('|');
-        if (mainParts.length < 2 || mainParts[1] == null || mainParts[1].trim() === '') {
-            return null;
-        }
-
-        return mainParts[1].trim();
+  protected createDirectoryQuery(filter: string) {
+    if (filter == null || filter === "") {
+      return null;
     }
 
-    protected createCustomSet(filter: string): [boolean, Set<string>] {
-        if (filter == null || filter === '') {
-            return null;
-        }
-
-        const mainParts = filter.split('|');
-        if (mainParts.length < 1 || mainParts[0] == null || mainParts[0].trim() === '') {
-            return null;
-        }
-
-        const parts = mainParts[0].split(':');
-        if (parts.length !== 2) {
-            return null;
-        }
-
-        const keyword = parts[0].trim().toLowerCase();
-        let exclude = true;
-        if (keyword === 'include') {
-            exclude = false;
-        } else if (keyword === 'exclude') {
-            exclude = true;
-        } else {
-            return null;
-        }
-
-        const set = new Set<string>();
-        const pieces = parts[1].split(',');
-        for (const p of pieces) {
-            set.add(p.trim().toLowerCase());
-        }
-
-        return [exclude, set];
+    const mainParts = filter.split("|");
+    if (mainParts.length < 2 || mainParts[1] == null || mainParts[1].trim() === "") {
+      return null;
     }
 
-    protected filterOutResult(setFilter: [boolean, Set<string>], result: string) {
-        if (setFilter != null) {
-            const cleanResult = result != null ? result.trim().toLowerCase() : '--';
-            const excluded = setFilter[0];
-            const set = setFilter[1];
+    return mainParts[1].trim();
+  }
 
-            if (excluded && set.has(cleanResult)) {
-                return true;
-            } else if (!excluded && !set.has(cleanResult)) {
-                return true;
-            }
-        }
-
-        return false;
+  protected createCustomSet(filter: string): [boolean, Set<string>] {
+    if (filter == null || filter === "") {
+      return null;
     }
 
-    protected filterUsersFromGroupsSet(users: UserEntry[], groups: GroupEntry[],
-        setFilter: [boolean, Set<string>], syncConfig: SyncConfiguration): UserEntry[] {
-        if (setFilter == null || users == null) {
-            return users;
-        }
-
-        return users.filter(u => {
-            if (u.deleted) {
-                return true;
-            }
-            if (u.disabled && syncConfig.removeDisabled) {
-                return true;
-            }
-
-            return groups.filter(g => g.userMemberExternalIds.has(u.externalId)).length > 0;
-        });
+    const mainParts = filter.split("|");
+    if (mainParts.length < 1 || mainParts[0] == null || mainParts[0].trim() === "") {
+      return null;
     }
 
-    protected forceGroup(force: boolean, users: UserEntry[]): boolean {
-        return force || (users != null && users.filter(u => !u.deleted && !u.disabled).length > 0);
+    const parts = mainParts[0].split(":");
+    if (parts.length !== 2) {
+      return null;
     }
+
+    const keyword = parts[0].trim().toLowerCase();
+    let exclude = true;
+    if (keyword === "include") {
+      exclude = false;
+    } else if (keyword === "exclude") {
+      exclude = true;
+    } else {
+      return null;
+    }
+
+    const set = new Set<string>();
+    const pieces = parts[1].split(",");
+    for (const p of pieces) {
+      set.add(p.trim().toLowerCase());
+    }
+
+    return [exclude, set];
+  }
+
+  protected filterOutResult(setFilter: [boolean, Set<string>], result: string) {
+    if (setFilter != null) {
+      const cleanResult = result != null ? result.trim().toLowerCase() : "--";
+      const excluded = setFilter[0];
+      const set = setFilter[1];
+
+      if (excluded && set.has(cleanResult)) {
+        return true;
+      } else if (!excluded && !set.has(cleanResult)) {
+        return true;
+      }
+    }
+
+    return false;
+  }
+
+  protected filterUsersFromGroupsSet(
+    users: UserEntry[],
+    groups: GroupEntry[],
+    setFilter: [boolean, Set<string>],
+    syncConfig: SyncConfiguration
+  ): UserEntry[] {
+    if (setFilter == null || users == null) {
+      return users;
+    }
+
+    return users.filter((u) => {
+      if (u.deleted) {
+        return true;
+      }
+      if (u.disabled && syncConfig.removeDisabled) {
+        return true;
+      }
+
+      return groups.filter((g) => g.userMemberExternalIds.has(u.externalId)).length > 0;
+    });
+  }
+
+  protected forceGroup(force: boolean, users: UserEntry[]): boolean {
+    return force || (users != null && users.filter((u) => !u.deleted && !u.disabled).length > 0);
+  }
 }

src/services/configuration.service.ts

@@ -1,229 +0,0 @@
-import { DirectoryType } from '../enums/directoryType';
-
-import { StorageService } from 'jslib/abstractions/storage.service';
-import { AzureConfiguration } from '../models/azureConfiguration';
-import { GSuiteConfiguration } from '../models/gsuiteConfiguration';
-import { LdapConfiguration } from '../models/ldapConfiguration';
-import { OktaConfiguration } from '../models/oktaConfiguration';
-import { OneLoginConfiguration } from '../models/oneLoginConfiguration';
-import { SyncConfiguration } from '../models/syncConfiguration';
-
-const StoredSecurely = '[STORED SECURELY]';
-const Keys = {
-    ldap: 'ldapPassword',
-    gsuite: 'gsuitePrivateKey',
-    azure: 'azureKey',
-    okta: 'oktaToken',
-    oneLogin: 'oneLoginClientSecret',
-    directoryConfigPrefix: 'directoryConfig_',
-    sync: 'syncConfig',
-    directoryType: 'directoryType',
-    userDelta: 'userDeltaToken',
-    groupDelta: 'groupDeltaToken',
-    lastUserSync: 'lastUserSync',
-    lastGroupSync: 'lastGroupSync',
-    lastSyncHash: 'lastSyncHash',
-    organizationId: 'organizationId',
-};
-
-export class ConfigurationService {
-    constructor(private storageService: StorageService, private secureStorageService: StorageService,
-        private useSecureStorageForSecrets = true) { }
-
-    async getDirectory<T>(type: DirectoryType): Promise<T> {
-        const config = await this.storageService.get<T>(Keys.directoryConfigPrefix + type);
-        if (config == null) {
-            return config;
-        }
-
-        if (this.useSecureStorageForSecrets) {
-            switch (type) {
-                case DirectoryType.Ldap:
-                    (config as any).password = await this.secureStorageService.get<string>(Keys.ldap);
-                    break;
-                case DirectoryType.AzureActiveDirectory:
-                    (config as any).key = await this.secureStorageService.get<string>(Keys.azure);
-                    break;
-                case DirectoryType.Okta:
-                    (config as any).token = await this.secureStorageService.get<string>(Keys.okta);
-                    break;
-                case DirectoryType.GSuite:
-                    (config as any).privateKey = await this.secureStorageService.get<string>(Keys.gsuite);
-                    break;
-                case DirectoryType.OneLogin:
-                    (config as any).clientSecret = await this.secureStorageService.get<string>(Keys.oneLogin);
-                    break;
-            }
-        }
-        return config;
-    }
-
-    async saveDirectory(type: DirectoryType,
-        config: LdapConfiguration | GSuiteConfiguration | AzureConfiguration | OktaConfiguration |
-            OneLoginConfiguration): Promise<any> {
-        const savedConfig: any = Object.assign({}, config);
-        if (this.useSecureStorageForSecrets) {
-            switch (type) {
-                case DirectoryType.Ldap:
-                    if (savedConfig.password == null) {
-                        await this.secureStorageService.remove(Keys.ldap);
-                    } else {
-                        await this.secureStorageService.save(Keys.ldap, savedConfig.password);
-                        savedConfig.password = StoredSecurely;
-                    }
-                    break;
-                case DirectoryType.AzureActiveDirectory:
-                    if (savedConfig.key == null) {
-                        await this.secureStorageService.remove(Keys.azure);
-                    } else {
-                        await this.secureStorageService.save(Keys.azure, savedConfig.key);
-                        savedConfig.key = StoredSecurely;
-                    }
-                    break;
-                case DirectoryType.Okta:
-                    if (savedConfig.token == null) {
-                        await this.secureStorageService.remove(Keys.okta);
-                    } else {
-                        await this.secureStorageService.save(Keys.okta, savedConfig.token);
-                        savedConfig.token = StoredSecurely;
-                    }
-                    break;
-                case DirectoryType.GSuite:
-                    if (savedConfig.privateKey == null) {
-                        await this.secureStorageService.remove(Keys.gsuite);
-                    } else {
-                        (config as GSuiteConfiguration).privateKey = savedConfig.privateKey =
-                            savedConfig.privateKey.replace(/\\n/g, '\n');
-                        await this.secureStorageService.save(Keys.gsuite, savedConfig.privateKey);
-                        savedConfig.privateKey = StoredSecurely;
-                    }
-                    break;
-                case DirectoryType.OneLogin:
-                    if (savedConfig.clientSecret == null) {
-                        await this.secureStorageService.remove(Keys.oneLogin);
-                    } else {
-                        await this.secureStorageService.save(Keys.oneLogin, savedConfig.clientSecret);
-                        savedConfig.clientSecret = StoredSecurely;
-                    }
-                    break;
-            }
-        }
-        await this.storageService.save(Keys.directoryConfigPrefix + type, savedConfig);
-    }
-
-    getSync(): Promise<SyncConfiguration> {
-        return this.storageService.get<SyncConfiguration>(Keys.sync);
-    }
-
-    saveSync(config: SyncConfiguration) {
-        return this.storageService.save(Keys.sync, config);
-    }
-
-    getDirectoryType(): Promise<DirectoryType> {
-        return this.storageService.get<DirectoryType>(Keys.directoryType);
-    }
-
-    async saveDirectoryType(type: DirectoryType) {
-        const currentType = await this.getDirectoryType();
-        if (type !== currentType) {
-            await this.clearStatefulSettings();
-        }
-
-        return this.storageService.save(Keys.directoryType, type);
-    }
-
-    getUserDeltaToken(): Promise<string> {
-        return this.storageService.get<string>(Keys.userDelta);
-    }
-
-    saveUserDeltaToken(token: string) {
-        if (token == null) {
-            return this.storageService.remove(Keys.userDelta);
-        } else {
-            return this.storageService.save(Keys.userDelta, token);
-        }
-    }
-
-    getGroupDeltaToken(): Promise<string> {
-        return this.storageService.get<string>(Keys.groupDelta);
-    }
-
-    saveGroupDeltaToken(token: string) {
-        if (token == null) {
-            return this.storageService.remove(Keys.groupDelta);
-        } else {
-            return this.storageService.save(Keys.groupDelta, token);
-        }
-    }
-
-    async getLastUserSyncDate(): Promise<Date> {
-        const dateString = await this.storageService.get<string>(Keys.lastUserSync);
-        if (dateString == null) {
-            return null;
-        }
-        return new Date(dateString);
-    }
-
-    saveLastUserSyncDate(date: Date) {
-        if (date == null) {
-            return this.storageService.remove(Keys.lastUserSync);
-        } else {
-            return this.storageService.save(Keys.lastUserSync, date);
-        }
-    }
-
-    async getLastGroupSyncDate(): Promise<Date> {
-        const dateString = await this.storageService.get<string>(Keys.lastGroupSync);
-        if (dateString == null) {
-            return null;
-        }
-        return new Date(dateString);
-    }
-
-    saveLastGroupSyncDate(date: Date) {
-        if (date == null) {
-            return this.storageService.remove(Keys.lastGroupSync);
-        } else {
-            return this.storageService.save(Keys.lastGroupSync, date);
-        }
-    }
-
-    getLastSyncHash(): Promise<string> {
-        return this.storageService.get<string>(Keys.lastSyncHash);
-    }
-
-    saveLastSyncHash(hash: string) {
-        if (hash == null) {
-            return this.storageService.remove(Keys.lastSyncHash);
-        } else {
-            return this.storageService.save(Keys.lastSyncHash, hash);
-        }
-    }
-
-    getOrganizationId(): Promise<string> {
-        return this.storageService.get<string>(Keys.organizationId);
-    }
-
-    async saveOrganizationId(id: string) {
-        const currentId = await this.getOrganizationId();
-        if (currentId !== id) {
-            await this.clearStatefulSettings();
-        }
-
-        if (id == null) {
-            return this.storageService.remove(Keys.organizationId);
-        } else {
-            return this.storageService.save(Keys.organizationId, id);
-        }
-    }
-
-    async clearStatefulSettings(hashToo = false) {
-        await this.saveUserDeltaToken(null);
-        await this.saveGroupDeltaToken(null);
-        await this.saveLastGroupSyncDate(null);
-        await this.saveLastUserSyncDate(null);
-        if (hashToo) {
-            await this.saveLastSyncHash(null);
-        }
-    }
-}

src/services/directory.service.ts

@@ -1,6 +1,6 @@
-import { GroupEntry } from '../models/groupEntry';
-import { UserEntry } from '../models/userEntry';
+import { GroupEntry } from "../models/groupEntry";
+import { UserEntry } from "../models/userEntry";
 
 export interface IDirectoryService {
-    getEntries(force: boolean, test: boolean): Promise<[GroupEntry[], UserEntry[]]>;
+  getEntries(force: boolean, test: boolean): Promise<[GroupEntry[], UserEntry[]]>;
 }

src/services/gsuite-directory.service.ts

@@ -1,248 +1,260 @@
-import { JWT } from 'google-auth-library';
-import {
-    admin_directory_v1,
-    google,
-} from 'googleapis';
+import { JWT } from "google-auth-library";
+import { admin_directory_v1, google } from "googleapis";
 
-import { DirectoryType } from '../enums/directoryType';
+import { DirectoryType } from "../enums/directoryType";
 
-import { GroupEntry } from '../models/groupEntry';
-import { GSuiteConfiguration } from '../models/gsuiteConfiguration';
-import { SyncConfiguration } from '../models/syncConfiguration';
-import { UserEntry } from '../models/userEntry';
+import { GroupEntry } from "../models/groupEntry";
+import { GSuiteConfiguration } from "../models/gsuiteConfiguration";
+import { SyncConfiguration } from "../models/syncConfiguration";
+import { UserEntry } from "../models/userEntry";
 
-import { BaseDirectoryService } from './baseDirectory.service';
-import { ConfigurationService } from './configuration.service';
-import { IDirectoryService } from './directory.service';
+import { BaseDirectoryService } from "./baseDirectory.service";
+import { IDirectoryService } from "./directory.service";
 
-import { I18nService } from 'jslib/abstractions/i18n.service';
-import { LogService } from 'jslib/abstractions/log.service';
+import { I18nService } from "jslib-common/abstractions/i18n.service";
+import { LogService } from "jslib-common/abstractions/log.service";
+import { StateService } from "../abstractions/state.service";
 
 export class GSuiteDirectoryService extends BaseDirectoryService implements IDirectoryService {
-    private client: JWT;
-    private service: admin_directory_v1.Admin;
-    private authParams: any;
-    private dirConfig: GSuiteConfiguration;
-    private syncConfig: SyncConfiguration;
+  private client: JWT;
+  private service: admin_directory_v1.Admin;
+  private authParams: any;
+  private dirConfig: GSuiteConfiguration;
+  private syncConfig: SyncConfiguration;
 
-    constructor(private configurationService: ConfigurationService, private logService: LogService,
-        private i18nService: I18nService) {
-        super();
-        this.service = google.admin('directory_v1');
+  constructor(
+    private logService: LogService,
+    private i18nService: I18nService,
+    private stateService: StateService
+  ) {
+    super();
+    this.service = google.admin("directory_v1");
+  }
+
+  async getEntries(force: boolean, test: boolean): Promise<[GroupEntry[], UserEntry[]]> {
+    const type = await this.stateService.getDirectoryType();
+    if (type !== DirectoryType.GSuite) {
+      return;
     }
 
-    async getEntries(force: boolean, test: boolean): Promise<[GroupEntry[], UserEntry[]]> {
-        const type = await this.configurationService.getDirectoryType();
-        if (type !== DirectoryType.GSuite) {
-            return;
-        }
-
-        this.dirConfig = await this.configurationService.getDirectory<GSuiteConfiguration>(DirectoryType.GSuite);
-        if (this.dirConfig == null) {
-            return;
-        }
-
-        this.syncConfig = await this.configurationService.getSync();
-        if (this.syncConfig == null) {
-            return;
-        }
-
-        await this.auth();
-
-        let users: UserEntry[] = [];
-        if (this.syncConfig.users) {
-            users = await this.getUsers();
-        }
-
-        let groups: GroupEntry[];
-        if (this.syncConfig.groups) {
-            const setFilter = this.createCustomSet(this.syncConfig.groupFilter);
-            groups = await this.getGroups(setFilter, users);
-            users = this.filterUsersFromGroupsSet(users, groups, setFilter, this.syncConfig);
-        }
-
-        return [groups, users];
+    this.dirConfig = await this.stateService.getDirectory<GSuiteConfiguration>(
+      DirectoryType.GSuite
+    );
+    if (this.dirConfig == null) {
+      return;
     }
 
-    private async getUsers(): Promise<UserEntry[]> {
-        const entries: UserEntry[] = [];
-        const query = this.createDirectoryQuery(this.syncConfig.userFilter);
-        let nextPageToken: string = null;
-
-        const filter = this.createCustomSet(this.syncConfig.userFilter);
-        while (true) {
-            this.logService.info('Querying users - nextPageToken:' + nextPageToken);
-            const p = Object.assign({ query: query, pageToken: nextPageToken }, this.authParams);
-            const res = await this.service.users.list(p);
-            if (res.status !== 200) {
-                throw new Error('User list API failed: ' + res.statusText);
-            }
-
-            nextPageToken = res.data.nextPageToken;
-            if (res.data.users != null) {
-                for (const user of res.data.users) {
-                    if (this.filterOutResult(filter, user.primaryEmail)) {
-                        continue;
-                    }
-                    const entry = this.buildUser(user, false);
-                    if (entry != null) {
-                        entries.push(entry);
-                    }
-                }
-            }
-
-            if (nextPageToken == null) {
-                break;
-            }
-        }
-
-        nextPageToken = null;
-        while (true) {
-            this.logService.info('Querying deleted users - nextPageToken:' + nextPageToken);
-            const p = Object.assign({ showDeleted: true, query: query, pageToken: nextPageToken }, this.authParams);
-            const delRes = await this.service.users.list(p);
-            if (delRes.status !== 200) {
-                throw new Error('Deleted user list API failed: ' + delRes.statusText);
-            }
-
-            nextPageToken = delRes.data.nextPageToken;
-            if (delRes.data.users != null) {
-                for (const user of delRes.data.users) {
-                    if (this.filterOutResult(filter, user.primaryEmail)) {
-                        continue;
-                    }
-                    const entry = this.buildUser(user, true);
-                    if (entry != null) {
-                        entries.push(entry);
-                    }
-                }
-            }
-
-            if (nextPageToken == null) {
-                break;
-            }
-        }
-
-        return entries;
+    this.syncConfig = await this.stateService.getSync();
+    if (this.syncConfig == null) {
+      return;
     }
 
-    private buildUser(user: admin_directory_v1.Schema$User, deleted: boolean) {
-        if ((user.emails == null || user.emails === '') && !deleted) {
-            return null;
-        }
+    await this.auth();
 
-        const entry = new UserEntry();
-        entry.referenceId = user.id;
-        entry.externalId = user.id;
-        entry.email = user.primaryEmail != null ? user.primaryEmail.trim().toLowerCase() : null;
-        entry.disabled = user.suspended || false;
-        entry.deleted = deleted;
+    let users: UserEntry[] = [];
+    if (this.syncConfig.users) {
+      users = await this.getUsers();
+    }
+
+    let groups: GroupEntry[];
+    if (this.syncConfig.groups) {
+      const setFilter = this.createCustomSet(this.syncConfig.groupFilter);
+      groups = await this.getGroups(setFilter, users);
+      users = this.filterUsersFromGroupsSet(users, groups, setFilter, this.syncConfig);
+    }
+
+    return [groups, users];
+  }
+
+  private async getUsers(): Promise<UserEntry[]> {
+    const entries: UserEntry[] = [];
+    const query = this.createDirectoryQuery(this.syncConfig.userFilter);
+    let nextPageToken: string = null;
+
+    const filter = this.createCustomSet(this.syncConfig.userFilter);
+    while (true) {
+      this.logService.info("Querying users - nextPageToken:" + nextPageToken);
+      const p = Object.assign({ query: query, pageToken: nextPageToken }, this.authParams);
+      const res = await this.service.users.list(p);
+      if (res.status !== 200) {
+        throw new Error("User list API failed: " + res.statusText);
+      }
+
+      nextPageToken = res.data.nextPageToken;
+      if (res.data.users != null) {
+        for (const user of res.data.users) {
+          if (this.filterOutResult(filter, user.primaryEmail)) {
+            continue;
+          }
+          const entry = this.buildUser(user, false);
+          if (entry != null) {
+            entries.push(entry);
+          }
+        }
+      }
+
+      if (nextPageToken == null) {
+        break;
+      }
+    }
+
+    nextPageToken = null;
+    while (true) {
+      this.logService.info("Querying deleted users - nextPageToken:" + nextPageToken);
+      const p = Object.assign(
+        { showDeleted: true, query: query, pageToken: nextPageToken },
+        this.authParams
+      );
+      const delRes = await this.service.users.list(p);
+      if (delRes.status !== 200) {
+        throw new Error("Deleted user list API failed: " + delRes.statusText);
+      }
+
+      nextPageToken = delRes.data.nextPageToken;
+      if (delRes.data.users != null) {
+        for (const user of delRes.data.users) {
+          if (this.filterOutResult(filter, user.primaryEmail)) {
+            continue;
+          }
+          const entry = this.buildUser(user, true);
+          if (entry != null) {
+            entries.push(entry);
+          }
+        }
+      }
+
+      if (nextPageToken == null) {
+        break;
+      }
+    }
+
+    return entries;
+  }
+
+  private buildUser(user: admin_directory_v1.Schema$User, deleted: boolean) {
+    if ((user.emails == null || user.emails === "") && !deleted) {
+      return null;
+    }
+
+    const entry = new UserEntry();
+    entry.referenceId = user.id;
+    entry.externalId = user.id;
+    entry.email = user.primaryEmail != null ? user.primaryEmail.trim().toLowerCase() : null;
+    entry.disabled = user.suspended || false;
+    entry.deleted = deleted;
+    return entry;
+  }
+
+  private async getGroups(
+    setFilter: [boolean, Set<string>],
+    users: UserEntry[]
+  ): Promise<GroupEntry[]> {
+    const entries: GroupEntry[] = [];
+    let nextPageToken: string = null;
+
+    while (true) {
+      this.logService.info("Querying groups - nextPageToken:" + nextPageToken);
+      const p = Object.assign({ pageToken: nextPageToken }, this.authParams);
+      const res = await this.service.groups.list(p);
+      if (res.status !== 200) {
+        throw new Error("Group list API failed: " + res.statusText);
+      }
+
+      nextPageToken = res.data.nextPageToken;
+      if (res.data.groups != null) {
+        for (const group of res.data.groups) {
+          if (!this.filterOutResult(setFilter, group.name)) {
+            const entry = await this.buildGroup(group, users);
+            entries.push(entry);
+          }
+        }
+      }
+
+      if (nextPageToken == null) {
+        break;
+      }
+    }
+
+    return entries;
+  }
+
+  private async buildGroup(group: admin_directory_v1.Schema$Group, users: UserEntry[]) {
+    let nextPageToken: string = null;
+
+    const entry = new GroupEntry();
+    entry.referenceId = group.id;
+    entry.externalId = group.id;
+    entry.name = group.name;
+
+    while (true) {
+      const p = Object.assign({ groupKey: group.id, pageToken: nextPageToken }, this.authParams);
+      const memRes = await this.service.members.list(p);
+      if (memRes.status !== 200) {
+        this.logService.warning("Group member list API failed: " + memRes.statusText);
         return entry;
+      }
+
+      nextPageToken = memRes.data.nextPageToken;
+      if (memRes.data.members != null) {
+        for (const member of memRes.data.members) {
+          if (member.type == null) {
+            continue;
+          }
+          const type = member.type.toLowerCase();
+          if (type === "user") {
+            if (member.status == null || member.status.toLowerCase() !== "active") {
+              continue;
+            }
+            entry.userMemberExternalIds.add(member.id);
+          } else if (type === "group") {
+            entry.groupMemberReferenceIds.add(member.id);
+          } else if (type === "customer") {
+            for (const user of users) {
+              entry.userMemberExternalIds.add(user.externalId);
+            }
+          }
+        }
+      }
+
+      if (nextPageToken == null) {
+        break;
+      }
     }
 
-    private async getGroups(setFilter: [boolean, Set<string>], users: UserEntry[]): Promise<GroupEntry[]> {
-        const entries: GroupEntry[] = [];
-        let nextPageToken: string = null;
+    return entry;
+  }
 
-        while (true) {
-            this.logService.info('Querying groups - nextPageToken:' + nextPageToken);
-            const p = Object.assign({ pageToken: nextPageToken }, this.authParams);
-            const res = await this.service.groups.list(p);
-            if (res.status !== 200) {
-                throw new Error('Group list API failed: ' + res.statusText);
-            }
-
-            nextPageToken = res.data.nextPageToken;
-            if (res.data.groups != null) {
-                for (const group of res.data.groups) {
-                    if (!this.filterOutResult(setFilter, group.name)) {
-                        const entry = await this.buildGroup(group, users);
-                        entries.push(entry);
-                    }
-                }
-            }
-
-            if (nextPageToken == null) {
-                break;
-            }
-        }
-
-        return entries;
+  private async auth() {
+    if (
+      this.dirConfig.clientEmail == null ||
+      this.dirConfig.privateKey == null ||
+      this.dirConfig.adminUser == null ||
+      this.dirConfig.domain == null
+    ) {
+      throw new Error(this.i18nService.t("dirConfigIncomplete"));
     }
 
-    private async buildGroup(group: admin_directory_v1.Schema$Group, users: UserEntry[]) {
-        let nextPageToken: string = null;
+    this.client = new google.auth.JWT({
+      email: this.dirConfig.clientEmail,
+      key: this.dirConfig.privateKey != null ? this.dirConfig.privateKey.trimLeft() : null,
+      subject: this.dirConfig.adminUser,
+      scopes: [
+        "https://www.googleapis.com/auth/admin.directory.user.readonly",
+        "https://www.googleapis.com/auth/admin.directory.group.readonly",
+        "https://www.googleapis.com/auth/admin.directory.group.member.readonly",
+      ],
+    });
 
-        const entry = new GroupEntry();
-        entry.referenceId = group.id;
-        entry.externalId = group.id;
-        entry.name = group.name;
+    await this.client.authorize();
 
-        while (true) {
-            const p = Object.assign({ groupKey: group.id, pageToken: nextPageToken }, this.authParams);
-            const memRes = await this.service.members.list(p);
-            if (memRes.status !== 200) {
-                this.logService.warning('Group member list API failed: ' + memRes.statusText);
-                return entry;
-            }
-
-            nextPageToken = memRes.data.nextPageToken;
-            if (memRes.data.members != null) {
-                for (const member of memRes.data.members) {
-                    if (member.type == null) {
-                        continue;
-                    }
-                    const type = member.type.toLowerCase();
-                    if (type === 'user') {
-                        if (member.status == null || member.status.toLowerCase() !== 'active') {
-                            continue;
-                        }
-                        entry.userMemberExternalIds.add(member.id);
-                    } else if (type === 'group') {
-                        entry.groupMemberReferenceIds.add(member.id);
-                    } else if (type === 'customer') {
-                        for (const user of users) {
-                            entry.userMemberExternalIds.add(user.externalId);
-                        }
-                    }
-                }
-            }
-
-            if (nextPageToken == null) {
-                break;
-            }
-        }
-
-        return entry;
+    this.authParams = {
+      auth: this.client,
+    };
+    if (this.dirConfig.domain != null && this.dirConfig.domain.trim() !== "") {
+      this.authParams.domain = this.dirConfig.domain;
     }
-
-    private async auth() {
-        if (this.dirConfig.clientEmail == null || this.dirConfig.privateKey == null ||
-            this.dirConfig.adminUser == null || this.dirConfig.domain == null) {
-            throw new Error(this.i18nService.t('dirConfigIncomplete'));
-        }
-
-        this.client = new google.auth.JWT({
-            email: this.dirConfig.clientEmail,
-            key: this.dirConfig.privateKey != null ? this.dirConfig.privateKey.trimLeft() : null,
-            subject: this.dirConfig.adminUser,
-            scopes: [
-                'https://www.googleapis.com/auth/admin.directory.user.readonly',
-                'https://www.googleapis.com/auth/admin.directory.group.readonly',
-                'https://www.googleapis.com/auth/admin.directory.group.member.readonly',
-            ],
-        });
-
-        await this.client.authorize();
-
-        this.authParams = {
-            auth: this.client,
-        };
-        if (this.dirConfig.domain != null && this.dirConfig.domain.trim() !== '') {
-            this.authParams.domain = this.dirConfig.domain;
-        }
-        if (this.dirConfig.customer != null && this.dirConfig.customer.trim() !== '') {
-            this.authParams.customer = this.dirConfig.customer;
-        }
+    if (this.dirConfig.customer != null && this.dirConfig.customer.trim() !== "") {
+      this.authParams.customer = this.dirConfig.customer;
     }
+  }
 }

src/services/i18n.service.ts

@@ -1,15 +1,18 @@
-import * as fs from 'fs';
-import * as path from 'path';
+import * as fs from "fs";
+import * as path from "path";
 
-import { I18nService as BaseI18nService } from 'jslib/services/i18n.service';
+import { I18nService as BaseI18nService } from "jslib-common/services/i18n.service";
 
 export class I18nService extends BaseI18nService {
-    constructor(systemLanguage: string, localesDirectory: string) {
-        super(systemLanguage, localesDirectory, (formattedLocale: string) => {
-            const filePath = path.join(__dirname, this.localesDirectory + '/' + formattedLocale + '/messages.json');
-            const localesJson = fs.readFileSync(filePath, 'utf8');
-            const locales = JSON.parse(localesJson.replace(/^\uFEFF/, '')); // strip the BOM
-            return Promise.resolve(locales);
-        });
-    }
+  constructor(systemLanguage: string, localesDirectory: string) {
+    super(systemLanguage, localesDirectory, (formattedLocale: string) => {
+      const filePath = path.join(
+        __dirname,
+        this.localesDirectory + "/" + formattedLocale + "/messages.json"
+      );
+      const localesJson = fs.readFileSync(filePath, "utf8");
+      const locales = JSON.parse(localesJson.replace(/^\uFEFF/, "")); // strip the BOM
+      return Promise.resolve(locales);
+    });
+  }
 }

src/services/keytarSecureStorage.service.ts

@@ -1,25 +1,25 @@
-import {
-    deletePassword,
-    getPassword,
-    setPassword,
-} from 'keytar';
+import { deletePassword, getPassword, setPassword } from "keytar";
 
-import { StorageService } from 'jslib/abstractions/storage.service';
+import { StorageService } from "jslib-common/abstractions/storage.service";
 
 export class KeytarSecureStorageService implements StorageService {
-    constructor(private serviceName: string) { }
+  constructor(private serviceName: string) {}
 
-    get<T>(key: string): Promise<T> {
-        return getPassword(this.serviceName, key).then(val => {
-            return JSON.parse(val) as T;
-        });
-    }
+  get<T>(key: string): Promise<T> {
+    return getPassword(this.serviceName, key).then((val) => {
+      return JSON.parse(val) as T;
+    });
+  }
 
-    save(key: string, obj: any): Promise<any> {
-        return setPassword(this.serviceName, key, JSON.stringify(obj));
-    }
+  async has(key: string): Promise<boolean> {
+    return (await this.get(key)) != null;
+  }
 
-    remove(key: string): Promise<any> {
-        return deletePassword(this.serviceName, key);
-    }
+  save(key: string, obj: any): Promise<any> {
+    return setPassword(this.serviceName, key, JSON.stringify(obj));
+  }
+
+  remove(key: string): Promise<any> {
+    return deletePassword(this.serviceName, key);
+  }
 }

src/services/ldap-directory.service.ts

@@ -1,448 +1,504 @@
-import * as fs from 'fs';
-import * as ldap from 'ldapjs';
+import * as fs from "fs";
+import * as ldap from "ldapjs";
 
-import { checkServerIdentity, PeerCertificate } from 'tls';
+import { checkServerIdentity, PeerCertificate } from "tls";
 
-import { DirectoryType } from '../enums/directoryType';
+import { DirectoryType } from "../enums/directoryType";
 
-import { GroupEntry } from '../models/groupEntry';
-import { LdapConfiguration } from '../models/ldapConfiguration';
-import { SyncConfiguration } from '../models/syncConfiguration';
-import { UserEntry } from '../models/userEntry';
+import { GroupEntry } from "../models/groupEntry";
+import { LdapConfiguration } from "../models/ldapConfiguration";
+import { SyncConfiguration } from "../models/syncConfiguration";
+import { UserEntry } from "../models/userEntry";
 
-import { ConfigurationService } from './configuration.service';
-import { IDirectoryService } from './directory.service';
+import { IDirectoryService } from "./directory.service";
 
-import { I18nService } from 'jslib/abstractions/i18n.service';
-import { LogService } from 'jslib/abstractions/log.service';
+import { I18nService } from "jslib-common/abstractions/i18n.service";
+import { LogService } from "jslib-common/abstractions/log.service";
+import { StateService } from "../abstractions/state.service";
 
-import { Utils } from 'jslib/misc/utils';
+import { Utils } from "jslib-common/misc/utils";
 
 const UserControlAccountDisabled = 2;
 
 export class LdapDirectoryService implements IDirectoryService {
-    private client: ldap.Client;
-    private dirConfig: LdapConfiguration;
-    private syncConfig: SyncConfiguration;
+  private client: ldap.Client;
+  private dirConfig: LdapConfiguration;
+  private syncConfig: SyncConfiguration;
 
-    constructor(private configurationService: ConfigurationService, private logService: LogService,
-        private i18nService: I18nService) { }
+  constructor(
+    private logService: LogService,
+    private i18nService: I18nService,
+    private stateService: StateService
+  ) {}
 
-    async getEntries(force: boolean, test: boolean): Promise<[GroupEntry[], UserEntry[]]> {
-        const type = await this.configurationService.getDirectoryType();
-        if (type !== DirectoryType.Ldap) {
-            return;
-        }
-
-        this.dirConfig = await this.configurationService.getDirectory<LdapConfiguration>(DirectoryType.Ldap);
-        if (this.dirConfig == null) {
-            return;
-        }
-
-        this.syncConfig = await this.configurationService.getSync();
-        if (this.syncConfig == null) {
-            return;
-        }
-
-        await this.bind();
-
-        let users: UserEntry[];
-        if (this.syncConfig.users) {
-            users = await this.getUsers(force);
-        }
-
-        let groups: GroupEntry[];
-        if (this.syncConfig.groups) {
-            let groupForce = force;
-            if (!groupForce && users != null) {
-                const activeUsers = users.filter(u => !u.deleted && !u.disabled);
-                groupForce = activeUsers.length > 0;
-            }
-            groups = await this.getGroups(groupForce);
-        }
-
-        await this.unbind();
-        return [groups, users];
+  async getEntries(force: boolean, test: boolean): Promise<[GroupEntry[], UserEntry[]]> {
+    const type = await this.stateService.getDirectoryType();
+    if (type !== DirectoryType.Ldap) {
+      return;
     }
 
-    private async getUsers(force: boolean): Promise<UserEntry[]> {
-        const lastSync = await this.configurationService.getLastUserSyncDate();
-        let filter = this.buildBaseFilter(this.syncConfig.userObjectClass, this.syncConfig.userFilter);
-        filter = this.buildRevisionFilter(filter, force, lastSync);
-
-        const path = this.makeSearchPath(this.syncConfig.userPath);
-        this.logService.info('User search: ' + path + ' => ' + filter);
-
-        const regularUsers = await this.search<UserEntry>(path, filter, (se: any) => this.buildUser(se, false));
-        if (!this.dirConfig.ad) {
-            return regularUsers;
-        }
-
-        try {
-            let deletedFilter = this.buildBaseFilter(this.syncConfig.userObjectClass, '(isDeleted=TRUE)');
-            deletedFilter = this.buildRevisionFilter(deletedFilter, force, lastSync);
-
-            const deletedPath = this.makeSearchPath('CN=Deleted Objects');
-            this.logService.info('Deleted user search: ' + deletedPath + ' => ' + deletedFilter);
-
-            const delControl = new (ldap as any).Control({ type: '1.2.840.113556.1.4.417', criticality: true });
-            const deletedUsers = await this.search<UserEntry>(deletedPath, deletedFilter,
-                (se: any) => this.buildUser(se, true), [delControl]);
-            return regularUsers.concat(deletedUsers);
-        } catch (e) {
-            this.logService.warning('Cannot query deleted users.');
-            return regularUsers;
-        }
+    this.dirConfig = await this.stateService.getDirectory<LdapConfiguration>(DirectoryType.Ldap);
+    if (this.dirConfig == null) {
+      return;
     }
 
-    private buildUser(searchEntry: any, deleted: boolean): UserEntry {
-        const user = new UserEntry();
-        user.referenceId = searchEntry.objectName;
-        user.deleted = deleted;
-
-        if (user.referenceId == null) {
-            return null;
-        }
-
-        user.externalId = this.getExternalId(searchEntry, user.referenceId);
-        user.disabled = this.entryDisabled(searchEntry);
-        user.email = this.getAttr(searchEntry, this.syncConfig.userEmailAttribute);
-        if (user.email == null && this.syncConfig.useEmailPrefixSuffix &&
-            this.syncConfig.emailPrefixAttribute != null && this.syncConfig.emailSuffix != null) {
-            const prefixAttr = this.getAttr(searchEntry, this.syncConfig.emailPrefixAttribute);
-            if (prefixAttr != null) {
-                user.email = prefixAttr + this.syncConfig.emailSuffix;
-            }
-        }
-
-        if (user.email != null) {
-            user.email = user.email.trim().toLowerCase();
-        }
-
-        if (!user.deleted && (user.email == null || user.email.trim() === '')) {
-            return null;
-        }
-
-        return user;
+    this.syncConfig = await this.stateService.getSync();
+    if (this.syncConfig == null) {
+      return;
     }
 
-    private async getGroups(force: boolean): Promise<GroupEntry[]> {
-        const entries: GroupEntry[] = [];
+    await this.bind();
 
-        const lastSync = await this.configurationService.getLastUserSyncDate();
-        const originalFilter = this.buildBaseFilter(this.syncConfig.groupObjectClass, this.syncConfig.groupFilter);
-        let filter = originalFilter;
-        const revisionFilter = this.buildRevisionFilter(filter, force, lastSync);
-        const searchSinceRevision = filter !== revisionFilter;
-        filter = revisionFilter;
+    let users: UserEntry[];
+    if (this.syncConfig.users) {
+      users = await this.getUsers(force);
+    }
 
-        const path = this.makeSearchPath(this.syncConfig.groupPath);
-        this.logService.info('Group search: ' + path + ' => ' + filter);
+    let groups: GroupEntry[];
+    if (this.syncConfig.groups) {
+      let groupForce = force;
+      if (!groupForce && users != null) {
+        const activeUsers = users.filter((u) => !u.deleted && !u.disabled);
+        groupForce = activeUsers.length > 0;
+      }
+      groups = await this.getGroups(groupForce);
+    }
 
-        let groupSearchEntries: any[] = [];
-        const initialSearchGroupIds = await this.search<string>(path, filter, (se: any) => {
-            groupSearchEntries.push(se);
-            return se.objectName;
+    await this.unbind();
+    return [groups, users];
+  }
+
+  private async getUsers(force: boolean): Promise<UserEntry[]> {
+    const lastSync = await this.stateService.getLastUserSync();
+    let filter = this.buildBaseFilter(this.syncConfig.userObjectClass, this.syncConfig.userFilter);
+    filter = this.buildRevisionFilter(filter, force, lastSync);
+
+    const path = this.makeSearchPath(this.syncConfig.userPath);
+    this.logService.info("User search: " + path + " => " + filter);
+
+    const regularUsers = await this.search<UserEntry>(path, filter, (se: any) =>
+      this.buildUser(se, false)
+    );
+    if (!this.dirConfig.ad) {
+      return regularUsers;
+    }
+
+    try {
+      let deletedFilter = this.buildBaseFilter(this.syncConfig.userObjectClass, "(isDeleted=TRUE)");
+      deletedFilter = this.buildRevisionFilter(deletedFilter, force, lastSync);
+
+      const deletedPath = this.makeSearchPath("CN=Deleted Objects");
+      this.logService.info("Deleted user search: " + deletedPath + " => " + deletedFilter);
+
+      const delControl = new (ldap as any).Control({
+        type: "1.2.840.113556.1.4.417",
+        criticality: true,
+      });
+      const deletedUsers = await this.search<UserEntry>(
+        deletedPath,
+        deletedFilter,
+        (se: any) => this.buildUser(se, true),
+        [delControl]
+      );
+      return regularUsers.concat(deletedUsers);
+    } catch (e) {
+      this.logService.warning("Cannot query deleted users.");
+      return regularUsers;
+    }
+  }
+
+  private buildUser(searchEntry: any, deleted: boolean): UserEntry {
+    const user = new UserEntry();
+    user.referenceId = searchEntry.objectName;
+    user.deleted = deleted;
+
+    if (user.referenceId == null) {
+      return null;
+    }
+
+    user.externalId = this.getExternalId(searchEntry, user.referenceId);
+    user.disabled = this.entryDisabled(searchEntry);
+    user.email = this.getAttr(searchEntry, this.syncConfig.userEmailAttribute);
+    if (
+      user.email == null &&
+      this.syncConfig.useEmailPrefixSuffix &&
+      this.syncConfig.emailPrefixAttribute != null &&
+      this.syncConfig.emailSuffix != null
+    ) {
+      const prefixAttr = this.getAttr(searchEntry, this.syncConfig.emailPrefixAttribute);
+      if (prefixAttr != null) {
+        user.email = prefixAttr + this.syncConfig.emailSuffix;
+      }
+    }
+
+    if (user.email != null) {
+      user.email = user.email.trim().toLowerCase();
+    }
+
+    if (!user.deleted && (user.email == null || user.email.trim() === "")) {
+      return null;
+    }
+
+    return user;
+  }
+
+  private async getGroups(force: boolean): Promise<GroupEntry[]> {
+    const entries: GroupEntry[] = [];
+
+    const lastSync = await this.stateService.getLastUserSync();
+    const originalFilter = this.buildBaseFilter(
+      this.syncConfig.groupObjectClass,
+      this.syncConfig.groupFilter
+    );
+    let filter = originalFilter;
+    const revisionFilter = this.buildRevisionFilter(filter, force, lastSync);
+    const searchSinceRevision = filter !== revisionFilter;
+    filter = revisionFilter;
+
+    const path = this.makeSearchPath(this.syncConfig.groupPath);
+    this.logService.info("Group search: " + path + " => " + filter);
+
+    let groupSearchEntries: any[] = [];
+    const initialSearchGroupIds = await this.search<string>(path, filter, (se: any) => {
+      groupSearchEntries.push(se);
+      return se.objectName;
+    });
+
+    if (searchSinceRevision && initialSearchGroupIds.length === 0) {
+      return [];
+    } else if (searchSinceRevision) {
+      groupSearchEntries = await this.search<string>(path, originalFilter, (se: any) => se);
+    }
+
+    const userFilter = this.buildBaseFilter(
+      this.syncConfig.userObjectClass,
+      this.syncConfig.userFilter
+    );
+    const userPath = this.makeSearchPath(this.syncConfig.userPath);
+    const userIdMap = new Map<string, string>();
+    await this.search<string>(userPath, userFilter, (se: any) => {
+      userIdMap.set(se.objectName, this.getExternalId(se, se.objectName));
+      return se;
+    });
+
+    for (const se of groupSearchEntries) {
+      const group = this.buildGroup(se, userIdMap);
+      if (group != null) {
+        entries.push(group);
+      }
+    }
+
+    return entries;
+  }
+
+  private buildGroup(searchEntry: any, userMap: Map<string, string>) {
+    const group = new GroupEntry();
+    group.referenceId = searchEntry.objectName;
+    if (group.referenceId == null) {
+      return null;
+    }
+
+    group.externalId = this.getExternalId(searchEntry, group.referenceId);
+
+    group.name = this.getAttr(searchEntry, this.syncConfig.groupNameAttribute);
+    if (group.name == null) {
+      group.name = this.getAttr(searchEntry, "cn");
+    }
+
+    if (group.name == null) {
+      return null;
+    }
+
+    const members = this.getAttrVals(searchEntry, this.syncConfig.memberAttribute);
+    if (members != null) {
+      for (const memDn of members) {
+        if (userMap.has(memDn) && !group.userMemberExternalIds.has(userMap.get(memDn))) {
+          group.userMemberExternalIds.add(userMap.get(memDn));
+        } else if (!group.groupMemberReferenceIds.has(memDn)) {
+          group.groupMemberReferenceIds.add(memDn);
+        }
+      }
+    }
+
+    return group;
+  }
+
+  private getExternalId(searchEntry: any, referenceId: string) {
+    const attrObj = this.getAttrObj(searchEntry, "objectGUID");
+    if (attrObj != null && attrObj._vals != null && attrObj._vals.length > 0) {
+      return this.bufToGuid(attrObj._vals[0]);
+    } else {
+      return referenceId;
+    }
+  }
+
+  private buildBaseFilter(objectClass: string, subFilter: string): string {
+    let filter = this.buildObjectClassFilter(objectClass);
+    if (subFilter != null && subFilter.trim() !== "") {
+      filter = "(&" + filter + subFilter + ")";
+    }
+    return filter;
+  }
+
+  private buildObjectClassFilter(objectClass: string): string {
+    return "(&(objectClass=" + objectClass + "))";
+  }
+
+  private buildRevisionFilter(baseFilter: string, force: boolean, lastRevisionDate: Date) {
+    const revisionAttr = this.syncConfig.revisionDateAttribute;
+    if (!force && lastRevisionDate != null && revisionAttr != null && revisionAttr.trim() !== "") {
+      const dateString = lastRevisionDate.toISOString().replace(/[-:T]/g, "").substr(0, 16) + "Z";
+      baseFilter = "(&" + baseFilter + "(" + revisionAttr + ">=" + dateString + "))";
+    }
+
+    return baseFilter;
+  }
+
+  private makeSearchPath(pathPrefix: string) {
+    if (this.dirConfig.rootPath.toLowerCase().indexOf("dc=") === -1) {
+      return pathPrefix;
+    }
+    if (this.dirConfig.rootPath != null && this.dirConfig.rootPath.trim() !== "") {
+      const trimmedRootPath = this.dirConfig.rootPath.trim().toLowerCase();
+      let path = trimmedRootPath.substr(trimmedRootPath.indexOf("dc="));
+      if (pathPrefix != null && pathPrefix.trim() !== "") {
+        path = pathPrefix.trim() + "," + path;
+      }
+      return path;
+    }
+
+    return null;
+  }
+
+  private getAttrObj(searchEntry: any, attr: string): any {
+    if (searchEntry == null || searchEntry.attributes == null) {
+      return null;
+    }
+
+    const attrs = searchEntry.attributes.filter((a: any) => a.type === attr);
+    if (
+      attrs == null ||
+      attrs.length === 0 ||
+      attrs[0].vals == null ||
+      attrs[0].vals.length === 0
+    ) {
+      return null;
+    }
+
+    return attrs[0];
+  }
+
+  private getAttrVals(searchEntry: any, attr: string): string[] {
+    const obj = this.getAttrObj(searchEntry, attr);
+    if (obj == null) {
+      return null;
+    }
+    return obj.vals;
+  }
+
+  private getAttr(searchEntry: any, attr: string): string {
+    const vals = this.getAttrVals(searchEntry, attr);
+    if (vals == null) {
+      return null;
+    }
+    return vals[0];
+  }
+
+  private entryDisabled(searchEntry: any): boolean {
+    const c = this.getAttr(searchEntry, "userAccountControl");
+    if (c != null) {
+      try {
+        const control = parseInt(c, null);
+        // tslint:disable-next-line
+        return (control & UserControlAccountDisabled) === UserControlAccountDisabled;
+      } catch (e) {
+        this.logService.error(e);
+      }
+    }
+
+    return false;
+  }
+
+  private async search<T>(
+    path: string,
+    filter: string,
+    processEntry: (searchEntry: any) => T,
+    controls: ldap.Control[] = []
+  ): Promise<T[]> {
+    const options: ldap.SearchOptions = {
+      filter: filter,
+      scope: "sub",
+      paged: this.dirConfig.pagedSearch,
+    };
+    const entries: T[] = [];
+    return new Promise<T[]>((resolve, reject) => {
+      this.client.search(path, options, controls, (err, res) => {
+        if (err != null) {
+          reject(err);
+          return;
+        }
+
+        res.on("error", (resErr) => {
+          reject(resErr);
         });
 
-        if (searchSinceRevision && initialSearchGroupIds.length === 0) {
-            return [];
-        } else if (searchSinceRevision) {
-            groupSearchEntries = await this.search<string>(path, originalFilter, (se: any) => se);
-        }
-
-        const userFilter = this.buildBaseFilter(this.syncConfig.userObjectClass, this.syncConfig.userFilter);
-        const userPath = this.makeSearchPath(this.syncConfig.userPath);
-        const userIdMap = new Map<string, string>();
-        await this.search<string>(userPath, userFilter, (se: any) => {
-            userIdMap.set(se.objectName, this.getExternalId(se, se.objectName));
-            return se;
+        res.on("searchEntry", (entry) => {
+          const e = processEntry(entry);
+          if (e != null) {
+            entries.push(e);
+          }
         });
 
-        for (const se of groupSearchEntries) {
-            const group = this.buildGroup(se, userIdMap);
-            if (group != null) {
-                entries.push(group);
-            }
+        res.on("end", (result) => {
+          resolve(entries);
+        });
+      });
+    });
+  }
+
+  private async bind(): Promise<any> {
+    return new Promise<void>((resolve, reject) => {
+      if (this.dirConfig.hostname == null || this.dirConfig.port == null) {
+        reject(this.i18nService.t("dirConfigIncomplete"));
+        return;
+      }
+      const protocol = "ldap" + (this.dirConfig.ssl && !this.dirConfig.startTls ? "s" : "");
+      const url = protocol + "://" + this.dirConfig.hostname + ":" + this.dirConfig.port;
+      const options: ldap.ClientOptions = {
+        url: url.trim().toLowerCase(),
+      };
+
+      const tlsOptions: any = {};
+      if (this.dirConfig.ssl) {
+        if (this.dirConfig.sslAllowUnauthorized) {
+          tlsOptions.rejectUnauthorized = !this.dirConfig.sslAllowUnauthorized;
         }
-
-        return entries;
-    }
-
-    private buildGroup(searchEntry: any, userMap: Map<string, string>) {
-        const group = new GroupEntry();
-        group.referenceId = searchEntry.objectName;
-        if (group.referenceId == null) {
-            return null;
-        }
-
-        group.externalId = this.getExternalId(searchEntry, group.referenceId);
-
-        group.name = this.getAttr(searchEntry, this.syncConfig.groupNameAttribute);
-        if (group.name == null) {
-            group.name = this.getAttr(searchEntry, 'cn');
-        }
-
-        if (group.name == null) {
-            return null;
-        }
-
-        const members = this.getAttrVals(searchEntry, this.syncConfig.memberAttribute);
-        if (members != null) {
-            for (const memDn of members) {
-                if (userMap.has(memDn) && !group.userMemberExternalIds.has(userMap.get(memDn))) {
-                    group.userMemberExternalIds.add(userMap.get(memDn));
-                } else if (!group.groupMemberReferenceIds.has(memDn)) {
-                    group.groupMemberReferenceIds.add(memDn);
-                }
-            }
-        }
-
-        return group;
-    }
-
-    private getExternalId(searchEntry: any, referenceId: string) {
-        const attrObj = this.getAttrObj(searchEntry, 'objectGUID');
-        if (attrObj != null && attrObj._vals != null && attrObj._vals.length > 0) {
-            return this.bufToGuid(attrObj._vals[0]);
+        if (!this.dirConfig.startTls) {
+          if (
+            this.dirConfig.sslCaPath != null &&
+            this.dirConfig.sslCaPath !== "" &&
+            fs.existsSync(this.dirConfig.sslCaPath)
+          ) {
+            tlsOptions.ca = [fs.readFileSync(this.dirConfig.sslCaPath)];
+          }
+          if (
+            this.dirConfig.sslCertPath != null &&
+            this.dirConfig.sslCertPath !== "" &&
+            fs.existsSync(this.dirConfig.sslCertPath)
+          ) {
+            tlsOptions.cert = fs.readFileSync(this.dirConfig.sslCertPath);
+          }
+          if (
+            this.dirConfig.sslKeyPath != null &&
+            this.dirConfig.sslKeyPath !== "" &&
+            fs.existsSync(this.dirConfig.sslKeyPath)
+          ) {
+            tlsOptions.key = fs.readFileSync(this.dirConfig.sslKeyPath);
+          }
         } else {
-            return referenceId;
+          if (
+            this.dirConfig.tlsCaPath != null &&
+            this.dirConfig.tlsCaPath !== "" &&
+            fs.existsSync(this.dirConfig.tlsCaPath)
+          ) {
+            tlsOptions.ca = [fs.readFileSync(this.dirConfig.tlsCaPath)];
+          }
         }
-    }
+      }
 
-    private buildBaseFilter(objectClass: string, subFilter: string): string {
-        let filter = this.buildObjectClassFilter(objectClass);
-        if (subFilter != null && subFilter.trim() !== '') {
-            filter = '(&' + filter + subFilter + ')';
-        }
-        return filter;
-    }
+      tlsOptions.checkServerIdentity = this.checkServerIdentityAltNames;
+      options.tlsOptions = tlsOptions;
 
-    private buildObjectClassFilter(objectClass: string): string {
-        return '(&(objectClass=' + objectClass + '))';
-    }
+      this.client = ldap.createClient(options);
 
-    private buildRevisionFilter(baseFilter: string, force: boolean, lastRevisionDate: Date) {
-        const revisionAttr = this.syncConfig.revisionDateAttribute;
-        if (!force && lastRevisionDate != null && revisionAttr != null && revisionAttr.trim() !== '') {
-            const dateString = lastRevisionDate.toISOString().replace(/[-:T]/g, '').substr(0, 16) + 'Z';
-            baseFilter = '(&' + baseFilter + '(' + revisionAttr + '>=' + dateString + '))';
-        }
+      const user =
+        this.dirConfig.username == null || this.dirConfig.username.trim() === ""
+          ? null
+          : this.dirConfig.username;
+      const pass =
+        this.dirConfig.password == null || this.dirConfig.password.trim() === ""
+          ? null
+          : this.dirConfig.password;
 
-        return baseFilter;
-    }
+      if (user == null || pass == null) {
+        reject(this.i18nService.t("usernamePasswordNotConfigured"));
+        return;
+      }
 
-    private makeSearchPath(pathPrefix: string) {
-        if (this.dirConfig.rootPath.toLowerCase().indexOf('dc=') === -1) {
-            return pathPrefix;
-        }
-        if (this.dirConfig.rootPath != null && this.dirConfig.rootPath.trim() !== '') {
-            const trimmedRootPath = this.dirConfig.rootPath.trim().toLowerCase();
-            let path = trimmedRootPath.substr(trimmedRootPath.indexOf('dc='));
-            if (pathPrefix != null && pathPrefix.trim() !== '') {
-                path = pathPrefix.trim() + ',' + path;
-            }
-            return path;
-        }
-
-        return null;
-    }
-
-    private getAttrObj(searchEntry: any, attr: string): any {
-        if (searchEntry == null || searchEntry.attributes == null) {
-            return null;
-        }
-
-        const attrs = searchEntry.attributes.filter((a: any) => a.type === attr);
-        if (attrs == null || attrs.length === 0 || attrs[0].vals == null || attrs[0].vals.length === 0) {
-            return null;
-        }
-
-        return attrs[0];
-    }
-
-    private getAttrVals(searchEntry: any, attr: string): string[] {
-        const obj = this.getAttrObj(searchEntry, attr);
-        if (obj == null) {
-            return null;
-        }
-        return obj.vals;
-    }
-
-    private getAttr(searchEntry: any, attr: string): string {
-        const vals = this.getAttrVals(searchEntry, attr);
-        if (vals == null) {
-            return null;
-        }
-        return vals[0];
-    }
-
-    private entryDisabled(searchEntry: any): boolean {
-        const c = this.getAttr(searchEntry, 'userAccountControl');
-        if (c != null) {
-            try {
-                const control = parseInt(c, null);
-                // tslint:disable-next-line
-                return (control & UserControlAccountDisabled) === UserControlAccountDisabled;
-            } catch { }
-        }
-
-        return false;
-    }
-
-    private async search<T>(path: string, filter: string, processEntry: (searchEntry: any) => T,
-        controls: ldap.Control[] = []): Promise<T[]> {
-        const options: ldap.SearchOptions = {
-            filter: filter,
-            scope: 'sub',
-            paged: this.dirConfig.pagedSearch,
-        };
-        const entries: T[] = [];
-        return new Promise<T[]>((resolve, reject) => {
-            this.client.search(path, options, controls, (err, res) => {
-                if (err != null) {
-                    reject(err);
-                    return;
-                }
-
-                res.on('error', resErr => {
-                    reject(resErr);
-                });
-
-                res.on('searchEntry', entry => {
-                    const e = processEntry(entry);
-                    if (e != null) {
-                        entries.push(e);
-                    }
-                });
-
-                res.on('end', result => {
-                    resolve(entries);
-                });
+      if (this.dirConfig.startTls && this.dirConfig.ssl) {
+        this.client.starttls(options.tlsOptions, undefined, (err, res) => {
+          if (err != null) {
+            reject(err.message);
+          } else {
+            this.client.bind(user, pass, (err2) => {
+              if (err2 != null) {
+                reject(err2.message);
+              } else {
+                resolve();
+              }
             });
+          }
         });
-    }
-
-    private async bind(): Promise<any> {
-        return new Promise((resolve, reject) => {
-            if (this.dirConfig.hostname == null || this.dirConfig.port == null) {
-                reject(this.i18nService.t('dirConfigIncomplete'));
-                return;
-            }
-            const protocol = 'ldap' + (this.dirConfig.ssl && !this.dirConfig.startTls ? 's' : '');
-            const url = protocol + '://' + this.dirConfig.hostname +
-                ':' + this.dirConfig.port;
-            const options: ldap.ClientOptions = {
-                url: url.trim().toLowerCase(),
-            };
-
-            const tlsOptions: any = {};
-            if (this.dirConfig.ssl) {
-                if (this.dirConfig.sslAllowUnauthorized) {
-                    tlsOptions.rejectUnauthorized = !this.dirConfig.sslAllowUnauthorized;
-                }
-                if (!this.dirConfig.startTls) {
-                    if (this.dirConfig.sslCaPath != null && this.dirConfig.sslCaPath !== '' &&
-                        fs.existsSync(this.dirConfig.sslCaPath)) {
-                        tlsOptions.ca = [fs.readFileSync(this.dirConfig.sslCaPath)];
-                    }
-                    if (this.dirConfig.sslCertPath != null && this.dirConfig.sslCertPath !== '' &&
-                        fs.existsSync(this.dirConfig.sslCertPath)) {
-                        tlsOptions.cert = fs.readFileSync(this.dirConfig.sslCertPath);
-                    }
-                    if (this.dirConfig.sslKeyPath != null && this.dirConfig.sslKeyPath !== '' &&
-                        fs.existsSync(this.dirConfig.sslKeyPath)) {
-                        tlsOptions.key = fs.readFileSync(this.dirConfig.sslKeyPath);
-                    }
-                } else {
-                    if (this.dirConfig.tlsCaPath != null && this.dirConfig.tlsCaPath !== '' &&
-                        fs.existsSync(this.dirConfig.tlsCaPath)) {
-                        tlsOptions.ca = [fs.readFileSync(this.dirConfig.tlsCaPath)];
-                    }
-                }
-            }
-
-            tlsOptions.checkServerIdentity = this.checkServerIdentityAltNames;
-            options.tlsOptions = tlsOptions;
-
-            this.client = ldap.createClient(options);
-
-            const user = this.dirConfig.username == null || this.dirConfig.username.trim() === '' ? null :
-                this.dirConfig.username;
-            const pass = this.dirConfig.password == null || this.dirConfig.password.trim() === '' ? null :
-                this.dirConfig.password;
-
-            if (user == null || pass == null) {
-                reject(this.i18nService.t('usernamePasswordNotConfigured'));
-                return;
-            }
-
-            if (this.dirConfig.startTls && this.dirConfig.ssl) {
-                this.client.starttls(options.tlsOptions, undefined, (err, res) => {
-                    if (err != null) {
-                        reject(err.message);
-                    } else {
-                        this.client.bind(user, pass, err2 => {
-                            if (err2 != null) {
-                                reject(err2.message);
-                            } else {
-                                resolve();
-                            }
-                        });
-                    }
-                });
-            } else {
-                this.client.bind(user, pass, err => {
-                    if (err != null) {
-                        reject(err.message);
-                    } else {
-                        resolve();
-                    }
-                });
-            }
+      } else {
+        this.client.bind(user, pass, (err) => {
+          if (err != null) {
+            reject(err.message);
+          } else {
+            resolve();
+          }
         });
-    }
+      }
+    });
+  }
 
-    private async unbind(): Promise<any> {
-        return new Promise((resolve, reject) => {
-            this.client.unbind(err => {
-                if (err != null) {
-                    reject(err);
-                } else {
-                    resolve();
-                }
-            });
-        });
-    }
-
-    private bufToGuid(buf: Buffer) {
-        const arr = new Uint8Array(buf);
-        const p1 = arr.slice(0, 4).reverse().buffer;
-        const p2 = arr.slice(4, 6).reverse().buffer;
-        const p3 = arr.slice(6, 8).reverse().buffer;
-        const p4 = arr.slice(8, 10).buffer;
-        const p5 = arr.slice(10).buffer;
-        const guid = Utils.fromBufferToHex(p1) + '-' + Utils.fromBufferToHex(p2) + '-' + Utils.fromBufferToHex(p3) +
-            '-' + Utils.fromBufferToHex(p4) + '-' + Utils.fromBufferToHex(p5);
-        return guid.toLowerCase();
-    }
-
-    private checkServerIdentityAltNames(host: string, cert: PeerCertificate) {
-        // Fixes the cert representation when subject is empty and altNames are present
-        // Required for node versions < 12.14.1 (which could be used for bwdc cli)
-        // Adapted from: https://github.com/auth0/ad-ldap-connector/commit/1f4dd2be6ed93dda591dd31ed5483a9b452a8d2a
-        // See https://github.com/nodejs/node/issues/11771 for details
-        if (cert && cert.subject == null && /(IP|DNS|URL)/.test(cert.subjectaltname)) {
-            cert.subject = {
-                C: null,
-                ST: null,
-                L: null,
-                O: null,
-                OU: null,
-                CN: null,
-            };
+  private async unbind(): Promise<void> {
+    return new Promise((resolve, reject) => {
+      this.client.unbind((err) => {
+        if (err != null) {
+          reject(err);
+        } else {
+          resolve();
         }
+      });
+    });
+  }
 
-        return checkServerIdentity(host, cert);
+  private bufToGuid(buf: Buffer) {
+    const arr = new Uint8Array(buf);
+    const p1 = arr.slice(0, 4).reverse().buffer;
+    const p2 = arr.slice(4, 6).reverse().buffer;
+    const p3 = arr.slice(6, 8).reverse().buffer;
+    const p4 = arr.slice(8, 10).buffer;
+    const p5 = arr.slice(10).buffer;
+    const guid =
+      Utils.fromBufferToHex(p1) +
+      "-" +
+      Utils.fromBufferToHex(p2) +
+      "-" +
+      Utils.fromBufferToHex(p3) +
+      "-" +
+      Utils.fromBufferToHex(p4) +
+      "-" +
+      Utils.fromBufferToHex(p5);
+    return guid.toLowerCase();
+  }
+
+  private checkServerIdentityAltNames(host: string, cert: PeerCertificate) {
+    // Fixes the cert representation when subject is empty and altNames are present
+    // Required for node versions < 12.14.1 (which could be used for bwdc cli)
+    // Adapted from: https://github.com/auth0/ad-ldap-connector/commit/1f4dd2be6ed93dda591dd31ed5483a9b452a8d2a
+    // See https://github.com/nodejs/node/issues/11771 for details
+    if (cert && cert.subject == null && /(IP|DNS|URL)/.test(cert.subjectaltname)) {
+      cert.subject = {
+        C: null,
+        ST: null,
+        L: null,
+        O: null,
+        OU: null,
+        CN: null,
+      };
     }
+
+    return checkServerIdentity(host, cert);
+  }
 }