passbolt-browser-extension 5.2.0 → 5.3.2

package/src/all/background_page/model/entity/actionLog/defaultActionLogEntity.test.data.js

@@ -0,0 +1,34 @@
+/**
+ * Passbolt ~ Open source password manager for teams
+ * Copyright (c) Passbolt SA (https://www.passbolt.com)
+ *
+ * Licensed under GNU Affero General Public License version 3 of the or any later version.
+ * For full copyright and license information, please see the LICENSE.txt
+ * Redistributions of files must retain the above copyright notice.
+ *
+ * @copyright     Copyright (c) Passbolt SA (https://www.passbolt.com)
+ * @license       https://opensource.org/licenses/AGPL-3.0 AGPL License
+ * @link          https://www.passbolt.com Passbolt(tm)
+ * @since         5.4.0
+ */
+import {v4 as uuidv4} from "uuid";
+
+export const defaultData = {
+  "id": uuidv4(),
+  "action_log_id": uuidv4(),
+  "type": "Resources.created",
+  "creator": {
+    "id": uuidv4(),
+    "username": "ada@passbolt.com",
+    "profile": {
+      "first_name": "Ada",
+      "last_name": "Lovelace",
+      "avatar": {
+        "url": {
+          "medium": "img\/public\/Avatar\/22\/47\/85\/50adf80e3534413abdd8e34c9be6d1b6\/50adf80e3534413abdd8e34c9be6d1b6.a99472d5.png",
+          "small": "img\/public\/Avatar\/22\/47\/85\/50adf80e3534413abdd8e34c9be6d1b6\/50adf80e3534413abdd8e34c9be6d1b6.65a0ba70.png"
+        }
+      }
+    },
+  }
+};

package/src/all/background_page/model/entity/resource/resourcesCollection.js

@@ -336,6 +336,31 @@ class ResourcesCollection extends EntityV2Collection {
     return result;
   }
 
+  /**
+   * Update the current resource collection with the given collection.
+   * If an element already exists, it is replaced, otherwise, it's added.
+   * Note: mutation of the original collection does not trigger collection validation (schema or build rules).
+   * @param {ResourcesCollection} resourcesCollection
+   */
+  updateWithCollection(resourcesCollection) {
+    assertType(resourcesCollection, ResourcesCollection);
+
+    const resourceMapByIdWithIndex = this.items.reduce((result, resource, currentIndex) => {
+      result[resource.id] = currentIndex;
+      return result;
+    }, {});
+
+    for (let i = 0; i < resourcesCollection.length; i++) {
+      const resource = resourcesCollection.items[i];
+      const mappedResourceIndex = resourceMapByIdWithIndex[resource.id];
+      if (typeof mappedResourceIndex === "undefined") {
+        this.push(resource, {validate: false});
+      } else {
+        this._items[mappedResourceIndex] = resource;
+      }
+    }
+  }
+
   /*
    * ==================================================
    * Static getters

package/src/all/background_page/model/entity/resource/resourcesCollection.test.js

@@ -446,4 +446,38 @@ describe("ResourcesCollection", () => {
       expect(() => collection.setDecryptedMetadataFromCollection("test")).toThrow('The `resourcesCollection` parameter should be a ResourcesCollection.');
     });
   });
+
+  describe("::updateWithCollection", () => {
+    it("should update the existing resources and add the new ones", () => {
+      expect.assertions(5);
+      const resource1 = defaultResourceDto();
+      const resource2 = defaultResourceDto();
+      const collection = new ResourcesCollection([resource1, resource2]);
+
+      const updatedResource2 = {
+        ...resource2,
+        metadata: defaultResourceMetadataDto({
+          name: "UPDATE - RESOURCE",
+        }),
+      };
+
+      const resource3 = defaultResourceDto();
+      const collectionForUpdate = new ResourcesCollection([resource3, updatedResource2]);
+
+      collection.updateWithCollection(collectionForUpdate);
+
+      expect(collection).toHaveLength(3);
+      expect(collection.items[0].id).toStrictEqual(resource1.id);
+      expect(collection.items[1].id).toStrictEqual(resource2.id);
+      expect(collection.items[1].metadata.name).toStrictEqual(updatedResource2.metadata.name);
+      expect(collection.items[2].id).toStrictEqual(resource3.id);
+    });
+
+    it("should assert its parameters", () => {
+      expect.assertions(1);
+      const collection = new ResourcesCollection([]);
+
+      expect(() => collection.updateWithCollection("test")).toThrow();
+    });
+  });
 });

package/src/all/background_page/model/import/resources/resourcesKdbxImportParser.test.js

@@ -371,7 +371,6 @@ describe("ResourcesKdbxImportParser", () => {
     const importEntity = new ImportResourcesFileEntity(importDto);
     const parser = new ResourcesKdbxImportParser(importEntity, resourceTypesCollection, metadataTypesSettings);
     await parser.parseImport();
-    console.log(importEntity);
 
     // Assert resources
     expect(importEntity.importResources.items).toHaveLength(2);

package/src/all/background_page/model/user/userModel.js

@@ -12,12 +12,9 @@
  * @since         3.0.0
  */
 import UserLocalStorage from "../../service/local_storage/userLocalStorage";
-import DeleteDryRunError from "../../error/deleteDryRunError";
 import UserService from "../../service/api/user/userService";
-import UserDeleteTransferEntity from "../entity/user/transfer/userDeleteTransferEntity";
 import UserEntity from "../entity/user/userEntity";
 import UsersCollection from "../entity/user/usersCollection";
-import PassboltApiFetchError from "passbolt-styleguide/src/shared/lib/Error/PassboltApiFetchError";
 import Validator from "validator";
 import RoleEntity from "passbolt-styleguide/src/shared/models/entity/role/roleEntity";
 import UserMeSessionStorageService from "../../service/sessionStorage/userMeSessionStorageService";
@@ -208,63 +205,6 @@ class UserModel {
     return  new UserEntity(userDto, {ignoreInvalidEntity});
   }
 
-  /**
-   * Check if a user can be deleted
-   *
-   * A user can not be deleted if:
-   * - they are the only owner of a shared resource
-   * - they are the only group manager of a group that owns a shared resource
-   * In such case ownership transfer is required.
-   *
-   * @param {string} userId The user id
-   * @param {UserDeleteTransferEntity} [transfer] optional ownership transfer information if needed
-   * @returns {Promise<void>}
-   * @throws {DeleteDryRunError} if some permissions must be transferred
-   * @public
-   */
-  async deleteDryRun(userId, transfer) {
-    try {
-      const deleteData = (transfer && transfer instanceof UserDeleteTransferEntity) ? transfer.toDto() : {};
-      await this.userService.delete(userId, deleteData, true);
-    } catch (error) {
-      if (error instanceof PassboltApiFetchError && error.data.code === 400 && error.data.body.errors) {
-        /*
-         * recast generic 400 error into a delete dry run error
-         * allowing validation of the returned entities and reuse down the line to transfer permissions
-         */
-        throw new DeleteDryRunError(error.message, error.data.body.errors);
-      }
-      throw error;
-    }
-  }
-
-  /**
-   * Delete a user and transfer ownership if needed
-   *
-   * @param {string} userId The user id
-   * @param {UserDeleteTransferEntity} [transfer] optional ownership transfer information if needed
-   * @returns {Promise<void>}
-   * @public
-   */
-  async delete(userId, transfer) {
-    try {
-      const deleteData = (transfer && transfer instanceof UserDeleteTransferEntity) ? transfer.toDto() : {};
-      await this.userService.delete(userId, deleteData);
-    } catch (error) {
-      if (error instanceof PassboltApiFetchError && error.data.code === 400 && error.data.body.errors) {
-        /*
-         * recast generic 400 error into a delete dry run error
-         * allowing validation of the returned entities and reuse down the line to transfer permissions
-         */
-        throw new DeleteDryRunError(error.message, error.data.body.errors);
-      }
-      throw error;
-    }
-
-    // Update local storage
-    await UserLocalStorage.delete(userId);
-  }
-
   /**
    * Request help when a user lost its credentials.
    * @param {AbstractAccountEntity} account The account the credentials have been lost for.

package/src/all/background_page/pagemod/appPagemod.js

@@ -39,7 +39,6 @@ import {LocaleEvents} from "../event/localeEvents";
 import {MobileEvents} from "../event/mobileEvents";
 import {PownedPasswordEvents} from '../event/pownedPasswordEvents';
 import {MfaEvents} from "../event/mfaEvents";
-import {ClipboardEvents} from "../event/clipboardEvents";
 import BuildApiClientOptionsService from "../service/account/buildApiClientOptionsService";
 import {RememberMeEvents} from "../event/rememberMeEvents";
 import CheckAuthStatusService from "../service/auth/checkAuthStatusService";
@@ -87,7 +86,6 @@ class App extends Pagemod {
       MobileEvents,
       PownedPasswordEvents,
       MfaEvents,
-      ClipboardEvents,
       RememberMeEvents,
       PermissionEvents,
       AccountEvents

package/src/all/background_page/pagemod/appPagemod.test.js

@@ -38,7 +38,6 @@ import {ThemeEvents} from "../event/themeEvents";
 import {MobileEvents} from "../event/mobileEvents";
 import {PownedPasswordEvents} from '../event/pownedPasswordEvents';
 import {MfaEvents} from "../event/mfaEvents";
-import {ClipboardEvents} from "../event/clipboardEvents";
 import {v4 as uuid} from "uuid";
 import BuildApiClientOptionsService from "../service/account/buildApiClientOptionsService";
 import {enableFetchMocks} from "jest-fetch-mock";
@@ -75,13 +74,12 @@ jest.spyOn(LocaleEvents, "listen").mockImplementation(jest.fn());
 jest.spyOn(MobileEvents, "listen").mockImplementation(jest.fn());
 jest.spyOn(PownedPasswordEvents, "listen").mockImplementation(jest.fn());
 jest.spyOn(MfaEvents, "listen").mockImplementation(jest.fn());
-jest.spyOn(ClipboardEvents, "listen").mockImplementation(jest.fn());
 jest.spyOn(RememberMeEvents, "listen").mockImplementation(jest.fn());
 jest.spyOn(PermissionEvents, "listen").mockImplementation(jest.fn());
 jest.spyOn(AccountEvents, "listen").mockImplementation(jest.fn());
 
 describe("App", () => {
-  beforeEach(async() => {
+  beforeEach(() => {
     jest.resetModules();
     jest.clearAllMocks();
     enableFetchMocks();
@@ -89,7 +87,7 @@ describe("App", () => {
 
   describe("App::attachEvents", () => {
     it("Should attach events", async() => {
-      expect.assertions(34);
+      expect.assertions(33);
       // data mocked
       const port = {
         _port: {
@@ -137,7 +135,6 @@ describe("App", () => {
       expect(MobileEvents.listen).toHaveBeenCalledWith(expectedPortAndTab, mockApiClient, mockedAccount);
       expect(PownedPasswordEvents.listen).toHaveBeenCalledWith(expectedPortAndTab, mockApiClient, mockedAccount);
       expect(MfaEvents.listen).toHaveBeenCalledWith(expectedPortAndTab, mockApiClient, mockedAccount);
-      expect(ClipboardEvents.listen).toHaveBeenCalledWith(expectedPortAndTab, mockApiClient, mockedAccount);
       expect(RememberMeEvents.listen).toHaveBeenCalledWith(expectedPortAndTab, mockApiClient, mockedAccount);
       expect(PermissionEvents.listen).toHaveBeenCalledWith(expectedPortAndTab, mockApiClient, mockedAccount);
       expect(AccountEvents.listen).toHaveBeenCalledWith(expectedPortAndTab, mockApiClient, mockedAccount);
@@ -168,7 +165,6 @@ describe("App", () => {
         MobileEvents,
         PownedPasswordEvents,
         MfaEvents,
-        ClipboardEvents,
         RememberMeEvents,
         PermissionEvents,
         AccountEvents

package/src/all/background_page/service/alarm/globalAlarmService.js

@@ -13,6 +13,7 @@
  */
 
 import StartLoopAuthSessionCheckService from "../auth/startLoopAuthSessionCheckService";
+import CopyToClipboardService from "../clipboard/copyToClipboardService";
 import KeepSessionAliveService from "../session_storage/keepSessionAliveService";
 import PassphraseStorageService from "../session_storage/passphraseStorageService";
 
@@ -20,6 +21,7 @@ const topLevelAlarmMapping = {
   [StartLoopAuthSessionCheckService.ALARM_NAME]: StartLoopAuthSessionCheckService.handleAuthStatusCheckAlarm,
   [PassphraseStorageService.ALARM_NAME]: PassphraseStorageService.handleFlushEvent,
   [KeepSessionAliveService.ALARM_NAME]: KeepSessionAliveService.handleKeepSessionAlive,
+  [CopyToClipboardService.ALARM_NAME]: CopyToClipboardService.handleClipboardTemporaryContentFlushEvent,
 };
 
 /**

package/src/all/background_page/service/api/actionLog/{actionLogService.js → actionLogApiService.js}

@@ -11,6 +11,7 @@
  * @link          https://www.passbolt.com Passbolt(tm)
  */
 import AbstractActionLogEntity from "../../../model/entity/actionLog/abstractActionLogEntity";
+import {assertUuid, assertNonEmptyString, assertNumber} from "../../../utils/assertions";
 import AbstractService from "../abstract/abstractService";
 
 const RESOURCE_SERVICE_RESOURCE_NAME = 'actionlog';
@@ -76,7 +77,9 @@ class ActionLogService extends AbstractService {
    */
   async findAllFor(foreignModel, foreignId, page, limit) {
     this.assertValidForeignModel(foreignModel);
-    this.assertValidId(foreignId);
+    assertNumber(page);
+    assertNumber(limit);
+    assertUuid(foreignId);
     if (!page || typeof page !== 'number') {
       throw new TypeError(`ActionLog page should be a valid integer.`);
     }
@@ -102,9 +105,7 @@ class ActionLogService extends AbstractService {
    * @public
    */
   assertValidForeignModel(foreignModel) {
-    if (!foreignModel || typeof foreignModel !== 'string') {
-      throw new TypeError(`ActionLog foreign model should be a valid string.`);
-    }
+    assertNonEmptyString(foreignModel, 'ActionLog foreign model should be a valid string.');
     if (!AbstractActionLogEntity.ALLOWED_FOREIGN_MODELS.includes(foreignModel)) {
       throw new TypeError(`ActionLog foreign model ${foreignModel} in not in the list of supported models.`);
     }

package/src/all/background_page/service/api/actionLog/actionLogApiService.test.js

@@ -0,0 +1,55 @@
+/**
+ * Passbolt ~ Open source password manager for teams
+ * Copyright (c) Passbolt SA (https://www.passbolt.com)
+ *
+ * Licensed under GNU Affero General Public License version 3 of the or any later version.
+ * For full copyright and license information, please see the LICENSE.txt
+ * Redistributions of files must retain the above copyright notice.
+ *
+ * @copyright     Copyright (c) Passbolt SA (https://www.passbolt.com)
+ * @license       https://opensource.org/licenses/AGPL-3.0 AGPL License
+ * @link          https://www.passbolt.com Passbolt(tm)
+ * @since         5.4.0
+ */
+
+import {enableFetchMocks} from "jest-fetch-mock";
+import {v4 as uuidv4} from "uuid";
+import {mockApiResponse} from '../../../../../../test/mocks/mockApiResponse';
+import ActionLogApiService from "./actionLogApiService";
+import AccountEntity from "../../../model/entity/account/accountEntity";
+import {defaultAccountDto} from "../../../model/entity/account/accountEntity.test.data";
+import BuildApiClientOptionsService from "../../account/buildApiClientOptionsService";
+import {defaultActionLogsCollection} from "../../../model/entity/actionLog/actionLogsCollection.test.data";
+
+describe("ActionLogService", () => {
+  let apiClientOptions, account;
+  beforeEach(async() => {
+    enableFetchMocks();
+    fetch.resetMocks();
+    account = new AccountEntity(defaultAccountDto());
+    apiClientOptions = BuildApiClientOptionsService.buildFromAccount(account);
+  });
+
+  describe('::findAllFor', () => {
+    it("Retrieves all action logs for a foreign model", async() => {
+      expect.assertions(2);
+
+      const apiResponse = [defaultActionLogsCollection];
+      fetch.doMockOnceIf(/actionlog\/resource/, () => mockApiResponse(apiResponse));
+
+      const service = new ActionLogApiService(apiClientOptions, account);
+      const result = await service.findAllFor("Resource", uuidv4(), 1, 5);
+
+      expect(result).toBeInstanceOf(Array);
+      expect(result).toHaveLength(apiResponse.length);
+    });
+
+    it("throws API error if the API encountered an issue", async() => {
+      expect.assertions(1);
+
+      const service = new ActionLogApiService(apiClientOptions, account);
+
+      await expect(() => service.findAllFor("Resource", uuidv4())).rejects.toThrow(TypeError);
+    });
+  });
+});

package/src/all/background_page/service/api/comment/{commentService.js → commentApiService.js}

@@ -12,12 +12,13 @@
  * @since         3.0.0
  */
 import CommentEntity from "../../../model/entity/comment/commentEntity";
+import {assertNonEmptyString} from "../../../utils/assertions";
 import AbstractService from "../abstract/abstractService";
 
 
 const COMMENT_SERVICE_RESOURCE_NAME = 'comments';
 
-class CommentService extends AbstractService {
+class CommentApiService extends AbstractService {
   /**
    * Constructor
    *
@@ -25,7 +26,7 @@ class CommentService extends AbstractService {
    * @public
    */
   constructor(apiClientOptions) {
-    super(apiClientOptions, CommentService.RESOURCE_NAME);
+    super(apiClientOptions, CommentApiService.RESOURCE_NAME);
   }
 
   /**
@@ -61,7 +62,7 @@ class CommentService extends AbstractService {
     this.assertValidId(foreignId);
     this.assertValidForeignModel(foreignModel);
 
-    contains = contains ? this.formatContainOptions(contains, CommentService.getSupportedContainOptions()) : null;
+    contains = contains ? this.formatContainOptions(contains, CommentApiService.getSupportedContainOptions()) : null;
     const urlOptions = {...contains};
 
     const url = this.apiClient.buildUrl(`${this.apiClient.baseUrl}/${foreignModel.toLowerCase()}/${foreignId}`, urlOptions || {});
@@ -122,13 +123,11 @@ class CommentService extends AbstractService {
    * @public
    */
   assertValidForeignModel(foreignModel) {
-    if (!foreignModel || typeof foreignModel !== 'string') {
-      throw new TypeError(`Comment foreign model should be a valid string.`);
-    }
+    assertNonEmptyString(foreignModel, `Comment foreign model should be a valid string.`);
     if (!CommentEntity.ALLOWED_FOREIGN_MODELS.includes(foreignModel)) {
       throw new TypeError(`Comment foreign model ${foreignModel} in not in the list of supported models.`);
     }
   }
 }
 
-export default CommentService;
+export default CommentApiService;

package/src/all/background_page/service/api/comment/commentApiService.test.js

@@ -0,0 +1,122 @@
+/**
+ * Passbolt ~ Open source password manager for teams
+ * Copyright (c) Passbolt SA (https://www.passbolt.com)
+ *
+ * Licensed under GNU Affero General Public License version 3 of the or any later version.
+ * For full copyright and license information, please see the LICENSE.txt
+ * Redistributions of files must retain the above copyright notice.
+ *
+ * @copyright     Copyright (c) Passbolt SA (https://www.passbolt.com)
+ * @license       https://opensource.org/licenses/AGPL-3.0 AGPL License
+ * @link          https://www.passbolt.com Passbolt(tm)
+ * @since         5.4.0
+ */
+
+import {enableFetchMocks} from "jest-fetch-mock";
+import {v4 as uuidv4} from "uuid";
+import {mockApiResponse} from '../../../../../../test/mocks/mockApiResponse';
+import CommentApiService from "./commentApiService";
+import AccountEntity from "../../../model/entity/account/accountEntity";
+import {defaultAccountDto} from "../../../model/entity/account/accountEntity.test.data";
+import BuildApiClientOptionsService from "../../account/buildApiClientOptionsService";
+import {defaultCommentCollectionDto} from "passbolt-styleguide/src/shared/models/entity/comment/commentEntityCollection.test.data";
+import {defaultCommentDto} from "passbolt-styleguide/src/shared/models/entity/comment/commentEntity.test.data";
+import PassboltServiceUnavailableError from "passbolt-styleguide/src/shared/lib/Error/PassboltServiceUnavailableError";
+import CommentEntity from "../../../model/entity/comment/commentEntity";
+import {mockApiResponseError} from "../../../../../../test/mocks/mockApiResponse";
+
+describe.only("ActionLogService", () => {
+  let apiClientOptions, account;
+  beforeEach(async() => {
+    enableFetchMocks();
+    fetch.resetMocks();
+    account = new AccountEntity(defaultAccountDto());
+    apiClientOptions = BuildApiClientOptionsService.buildFromAccount(account);
+  });
+
+  describe('::findAll', () => {
+    it("retrieves the comments from API", async() => {
+      expect.assertions(2);
+
+      const commentsCollection = [defaultCommentCollectionDto()];
+      fetch.doMockOnceIf(/comments\/resource/, () => mockApiResponse(commentsCollection));
+
+      const service = new CommentApiService(apiClientOptions, account);
+      const resultDto = await service.findAll('Resource', uuidv4(), {creator: true});
+
+      expect(resultDto).toBeInstanceOf(Array);
+      expect(resultDto).toHaveLength(commentsCollection.length);
+    });
+
+    it("throws API error if the API encountered an issue", async() => {
+      expect.assertions(1);
+      fetch.doMockOnceIf(/comments\/resource/, () => mockApiResponseError(500, "Something wrong happened!"));
+
+      const service = new CommentApiService(apiClientOptions);
+
+      await expect(() => service.findAll('Resource')).rejects.toThrow(TypeError);
+    });
+
+    it("throws service unavailable error if an error occurred but not from the API (by instance cloudflare)", async() => {
+      expect.assertions(1);
+      fetch.doMockOnceIf(/comments\/resource/, () => { throw new Error("Service unavailable"); });
+
+      const service = new CommentApiService(apiClientOptions);
+
+      await expect(() => service.findAll('Resource', uuidv4(), {creator: true})).rejects.toThrow(PassboltServiceUnavailableError);
+    });
+  });
+
+  describe('::create', () => {
+    it("Create a comment", async() => {
+      expect.assertions(2);
+
+      const commentDto = defaultCommentDto({}, {withCreator: false, withModifier: false});
+
+      const payload = new CommentEntity(commentDto);
+      let reqPayload;
+      fetch.doMockOnceIf(/comments\/resource/, async req => {
+        expect(req.method).toEqual("POST");
+        reqPayload = await req.json();
+        return mockApiResponse(defaultCommentDto({...reqPayload, id: commentDto.id}));
+      });
+
+      const service = new CommentApiService(apiClientOptions);
+      const resultDto = await service.create(payload._props);
+
+      expect(resultDto).toEqual(expect.objectContaining(commentDto));
+    });
+
+    it("throws an error if input is invalid ", async() => {
+      expect.assertions(1);
+
+      const service = new CommentApiService(apiClientOptions);
+
+      await expect(() => service.create(42, {withCreator: false, withModifier: false})).rejects.toThrow(TypeError);
+    });
+  });
+
+
+  describe('::delete', () => {
+    it("Delete a comment", async() => {
+      expect.assertions(1);
+
+      const deleteCommentId = uuidv4();
+      fetch.doMockOnceIf(new RegExp(`/comments\/${deleteCommentId}\.json`), async req => {
+        expect(req.method).toEqual("DELETE");
+        return mockApiResponse({});
+      });
+
+      const service = new CommentApiService(apiClientOptions);
+      await service.delete(deleteCommentId);
+    });
+
+    it("throws an invalid parameter error if the id parameter is not valid", async() => {
+      expect.assertions(1);
+
+      const service = new CommentApiService(apiClientOptions);
+
+      await expect(() => service.delete(42)).rejects.toThrow(Error);
+    });
+  });
+});

package/src/all/background_page/service/api/resource/resourceService.js

@@ -73,6 +73,7 @@ class ResourceService extends AbstractService {
       'has-id',
       // if tag plugin
       'has-tag',
+      "has-parent",
     ];
   }
 

package/src/all/background_page/service/auth/postLogoutService.js

@@ -19,6 +19,7 @@ import resourceInProgressCacheService from "../cache/resourceInProgressCache.ser
 import OnExtensionUpdateAvailableService from "../extension/onExtensionUpdateAvailableService";
 import InformCallToActionPagemod from "../../pagemod/informCallToActionPagemod";
 import WorkerService from "../worker/workerService";
+import CopyToClipboardService from "../clipboard/copyToClipboardService";
 class PostLogoutService {
   /**
    * Execute all processes after a logout
@@ -27,6 +28,7 @@ class PostLogoutService {
   static async exec() {
     await PostLogoutService.sendLogoutEventForWorkers();
     await LocalStorageService.flush();
+    await (new CopyToClipboardService()).flushTemporaryContentIfAny();
     await StartLoopAuthSessionCheckService.clearAlarm();
     toolbarService.handleUserLoggedOut();
     resourceInProgressCacheService.reset();

package/src/all/background_page/service/auth/postLogoutService.test.js

@@ -26,6 +26,7 @@ import StartLoopAuthSessionCheckService from "./startLoopAuthSessionCheckService
 import resourceInProgressCacheService from "../cache/resourceInProgressCache.service";
 import OnExtensionUpdateAvailableService from "../extension/onExtensionUpdateAvailableService";
 import toolbarService from "../toolbar/toolbarService";
+import CopyToClipboardService from "../clipboard/copyToClipboardService";
 
 describe("PostLogoutService", () => {
   beforeEach(() => {
@@ -84,11 +85,12 @@ describe("PostLogoutService", () => {
     });
 
     it("Should call all services that needs to run processes on logout", async() => {
-      expect.assertions(5);
+      expect.assertions(6);
       jest.spyOn(PortManager, "isPortExist").mockImplementation(() => false);
       jest.spyOn(LocalStorageService, "flush");
       jest.spyOn(toolbarService, "handleUserLoggedOut");
       jest.spyOn(StartLoopAuthSessionCheckService, "clearAlarm");
+      jest.spyOn(CopyToClipboardService.prototype, "flushTemporaryContentIfAny");
       jest.spyOn(resourceInProgressCacheService, "reset");
       jest.spyOn(OnExtensionUpdateAvailableService, "handleUserLoggedOut");
 
@@ -99,6 +101,7 @@ describe("PostLogoutService", () => {
       expect(StartLoopAuthSessionCheckService.clearAlarm).toHaveBeenCalledTimes(1);
       expect(resourceInProgressCacheService.reset).toHaveBeenCalledTimes(1);
       expect(OnExtensionUpdateAvailableService.handleUserLoggedOut).toHaveBeenCalledTimes(1);
+      expect(CopyToClipboardService.prototype.flushTemporaryContentIfAny).toHaveBeenCalledTimes(1);
     });
   });
 });

package/src/all/background_page/service/browser/browserService.js

@@ -0,0 +1,22 @@
+/**
+ * Passbolt ~ Open source password manager for teams
+ * Copyright (c) Passbolt SA (https://www.passbolt.com)
+ *
+ * Licensed under GNU Affero General Public License version 3 of the or any later version.
+ * For full copyright and license information, please see the LICENSE.txt
+ * Redistributions of files must retain the above copyright notice.
+ *
+ * @copyright     Copyright (c) Passbolt SA (https://www.passbolt.com)
+ * @license       https://opensource.org/licenses/AGPL-3.0 AGPL License
+ * @link          https://www.passbolt.com Passbolt(tm)
+ * @since         5.3.2
+ */
+
+/**
+ * The service aims to help get browser information.
+ */
+export default class BrowserService {
+  static isFirefox() {
+    return browser.runtime.getURL("/").startsWith("moz-extension://");
+  }
+}

package/src/all/background_page/service/clipboard/clipboardProviderService.js

@@ -0,0 +1,40 @@
+/**
+ * Passbolt ~ Open source password manager for teams
+ * Copyright (c) Passbolt SA (https://www.passbolt.com)
+ *
+ * Licensed under GNU Affero General Public License version 3 of the or any later version.
+ * For full copyright and license information, please see the LICENSE.txt
+ * Redistributions of files must retain the above copyright notice.
+ *
+ * @copyright     Copyright (c) Passbolt SA (https://www.passbolt.com)
+ * @license       https://opensource.org/licenses/AGPL-3.0 AGPL License
+ * @link          https://www.passbolt.com Passbolt(tm)
+ * @since         5.3.2
+ */
+import EdgeBackgroundPageClipboardService from "../../../../chrome/polyfill/clipboard/edgeBackgroundPageClipboardService";
+import BrowserService from "../browser/browserService";
+
+/**
+ * The service retrieves the appropriate clipboard provider for the current environment: Edge, Chrome, or Firefox.
+ */
+export default class ClipboardProviderService {
+  /**
+   * Returns a clipboard API that works for the currently used browser.
+   * @returns {Clipboard}
+   */
+  static getClipboard() {
+    //is Chrome with MV3?
+    if (typeof customNavigatorClipboard !== "undefined") {
+      // eslint-disable-next-line no-undef
+      return customNavigatorClipboard;
+    }
+
+    const isMV2 = chrome.runtime.getManifest().manifest_version === 2;
+    if (!BrowserService.isFirefox() && isMV2) {
+      //it's not firefox and it's MV2 => it's most probably Edge then
+      return EdgeBackgroundPageClipboardService;
+    }
+    //by default we provide the default clipboard
+    return navigator.clipboard;
+  }
+}