passbolt-browser-extension 3.0.6 → 4.6.2

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

@@ -1,51 +1,62 @@
 /**
  * Passbolt ~ Open source password manager for teams
- * Copyright (c) Passbolt SA (https://www.passbolt.com)
+ * Copyright (c) 2023 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)
+ * @copyright     Copyright (c) 2023 Passbolt SA (https://www.passbolt.com)
  * @license       https://opensource.org/licenses/AGPL-3.0 AGPL License
  * @link          https://www.passbolt.com Passbolt(tm)
+ * @since         4.0.0
  */
-const {PageMod} = require('../sdk/page-mod');
-const app = require('../app');
+import Pagemod from "./pagemod";
+import {ConfigEvents} from "../event/configEvents";
+import BuildApiClientOptionsService
+  from "../service/account/buildApiClientOptionsService";
+import {SetupEvents} from "../event/setupEvents";
+import BuildAccountSetupService from "../service/setup/buildAccountSetupService";
+import {PownedPasswordEvents} from "../event/pownedPasswordEvents";
+import OrganizationSettingsModel from "../model/organizationSettings/organizationSettingsModel";
 
-/*
- * This pagemod help bootstrap the first step of the setup process from a passbolt server app page
- * The pattern for this url, driving the setup bootstrap, is defined in config.json
- */
-const Setup = function () {};
-Setup._pageMod = undefined;
-
-Setup.init = function () {
-  if (typeof Setup._pageMod !== 'undefined') {
-    Setup._pageMod.destroy();
-    Setup._pageMod = undefined;
+class Setup extends Pagemod {
+  /**
+   * @inheritDoc
+   * @returns {string}
+   */
+  get appName() {
+    return "Setup";
   }
 
-  Setup._pageMod = new PageMod({
-    name: 'Setup',
-    include: 'about:blank?passbolt=passbolt-iframe-setup',
-    contentScriptWhen: 'ready',
-    contentScriptFile: [
-			// Warning: script and styles need to be modified in
-			// chrome/data/passbolt-iframe-setup.html
-		],
-    onAttach: function (worker) {
-      app.events.config.listen(worker);
-      app.events.siteSettings.listen(worker);
-      app.events.setup.listen(worker);
+  /**
+   * @inheritDoc
+   */
+  get events() {
+    return [
+      ConfigEvents,
+      SetupEvents,
+      PownedPasswordEvents
+    ];
+  }
 
-      /*
-       * Keep the pagemod event listeners at the end of the list, it answers to an event that allows
-       * the content code to know when the background page is ready.
-       */
-      app.events.pagemod.listen(worker);
+  /**
+   * @inheritDoc
+   */
+  async attachEvents(port) {
+    try {
+      const tab = port._port.sender.tab;
+      const account = BuildAccountSetupService.buildFromSetupUrl(tab.url);
+      const apiClientOptions = await BuildApiClientOptionsService.buildFromAccount(account);
+      await (new OrganizationSettingsModel(apiClientOptions)).getOrFind(true);
+      for (const event of this.events) {
+        event.listen({port, tab}, apiClientOptions, account);
+      }
+    } catch (error) {
+      // Unexpected error, this pagemod shouldn't have been initialized as the bootstrapRecoverPagemod should have raised an exception and not inject this iframe.
+      console.error(error);
     }
-  });
-};
+  }
+}
 
-exports.Setup = Setup;
+export default new Setup();

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

@@ -0,0 +1,73 @@
+/**
+ * Passbolt ~ Open source password manager for teams
+ * Copyright (c) 2022 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) 2022 Passbolt SA (https://www.passbolt.com)
+ * @license       https://opensource.org/licenses/AGPL-3.0 AGPL License
+ * @link          https://www.passbolt.com Passbolt(tm)
+ * @since         3.9.0
+ */
+import Setup from "./setupPagemod";
+import {ConfigEvents} from "../event/configEvents";
+import {SetupEvents} from "../event/setupEvents";
+import BuildApiClientOptionsService
+  from "../service/account/buildApiClientOptionsService";
+import BuildAccountSetupService from "../service/setup/buildAccountSetupService";
+import {PownedPasswordEvents} from '../event/pownedPasswordEvents';
+import {enableFetchMocks} from "jest-fetch-mock";
+
+jest.spyOn(BuildAccountSetupService, "buildFromSetupUrl");
+jest.spyOn(BuildApiClientOptionsService, "buildFromAccount");
+jest.spyOn(ConfigEvents, "listen").mockImplementation(jest.fn());
+jest.spyOn(SetupEvents, "listen").mockImplementation(jest.fn());
+jest.spyOn(PownedPasswordEvents, "listen").mockImplementation(jest.fn());
+
+describe("Setup", () => {
+  beforeEach(async() => {
+    jest.resetModules();
+    jest.clearAllMocks();
+    enableFetchMocks();
+  });
+
+  describe("Setup::attachEvents", () => {
+    it("Should attach events", async() => {
+      expect.assertions(8);
+      // data mocked
+      const port = {
+        _port: {
+          sender: {
+            tab: {
+              url: "https://passbolt.dev/setup/start/571bec7e-6cce-451d-b53a-f8c93e147228/5ea0fc9c-b180-4873-8e00-9457862e43e0"
+            }
+          }
+        }
+      };
+      jest.spyOn(browser.cookies, "get").mockImplementation(() => ({value: "csrf-token"}));
+      // process
+      await Setup.attachEvents(port);
+      // expectations
+      expect(BuildAccountSetupService.buildFromSetupUrl).toHaveBeenCalledWith(port._port.sender.tab.url);
+      expect(BuildApiClientOptionsService.buildFromAccount).toHaveBeenCalled();
+      expect(ConfigEvents.listen).toHaveBeenCalled();
+      expect(SetupEvents.listen).toHaveBeenCalled();
+      expect(PownedPasswordEvents.listen).toHaveBeenCalled();
+      expect(Setup.events).toStrictEqual([ConfigEvents, SetupEvents, PownedPasswordEvents]);
+      expect(Setup.mustReloadOnExtensionUpdate).toBeFalsy();
+      expect(Setup.appName).toBe('Setup');
+    });
+  });
+
+  describe("Setup::canBeAttachedTo", () => {
+    it("Should have the canBeAttachedTo not valid", async() => {
+      expect.assertions(1);
+      // process
+      const canBeAttachedTo = await Setup.canBeAttachedTo({});
+      // expectations
+      expect(canBeAttachedTo).toBeFalsy();
+    });
+  });
+});

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

@@ -1,44 +1,91 @@
 /**
- * WebIntegration pagemod.
+ * Passbolt ~ Open source password manager for teams
+ * Copyright (c) 2023 Passbolt SA (https://www.passbolt.com)
  *
- * This pagemod allow inserting classes to help any page
- * to know about the status of the extension, in a modernizr fashion
+ * 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 (c) 2017 Passbolt SARL
- * @licence GNU Affero General Public License http://www.gnu.org/licenses/agpl-3.0.en.html
+ * @copyright     Copyright (c) 2023 Passbolt SA (https://www.passbolt.com)
+ * @license       https://opensource.org/licenses/AGPL-3.0 AGPL License
+ * @link          https://www.passbolt.com Passbolt(tm)
+ * @since         4.0.0
  */
-const app = require('../app');
-const {PageMod} = require('../sdk/page-mod');
-const Worker = require('../model/worker');
+import Pagemod from "./pagemod";
+import User from "../model/user";
+import {ConfigEvents} from "../event/configEvents";
+import {WebIntegrationEvents} from "../event/webIntegrationEvents";
+import {OrganizationSettingsEvents} from "../event/organizationSettingsEvents";
+import {PortEvents} from "../event/portEvents";
+import ParseWebIntegrationUrlService from "../service/webIntegration/parseWebIntegrationUrlService";
 
-const WebIntegration = function () {};
-WebIntegration._pageMod = undefined;
+class WebIntegration extends Pagemod {
+  /**
+   * @inheritDoc
+   * @returns {string}
+   */
+  get appName() {
+    return "WebIntegration";
+  }
+
+  /**
+   * @inheritDoc
+   */
+  get contentStyleFiles() {
+    return [];
+  }
 
-WebIntegration.init = function () {
-  if (typeof WebIntegration._pageMod !== 'undefined') {
-    WebIntegration._pageMod.destroy();
-    WebIntegration._pageMod = undefined;
+  /**
+   * @inheritDoc
+   */
+  get contentScriptFiles() {
+    return [
+      'contentScripts/js/dist/browser-integration/vendors.js',
+      'contentScripts/js/dist/browser-integration/browser-integration.js'
+    ];
   }
 
-  WebIntegration._pageMod = new PageMod({
-    name: 'WebIntegration',
-    include: new RegExp('.*'),
-    contentScriptWhen: 'ready',
-    contentStyleFile: [],
-    contentScriptFile: [
-      'data/vendors/jquery.js',
-      'data/vendors/dom-testing-library-event.js',
-      'data/js/lib/port.js',
-      'data/js/lib/request.js',
-      'data/js/lib/message.js',
-      'data/js/quickaccess/quickaccess.js',
-      'content_scripts/js/bootstrap.js'
-    ],
-    attachTo: {existing: true, reload: false},
-    onAttach: function (worker) {
-      Worker.add('WebIntegration', worker);
-      app.events.config.listen(worker);
+  /**
+   * @inheritDoc
+   */
+  get events() {
+    return [
+      ConfigEvents,
+      WebIntegrationEvents,
+      OrganizationSettingsEvents,
+      PortEvents,
+    ];
+  }
+
+  /**
+   * @inheritDoc
+   */
+  async canBeAttachedTo(frameDetails) {
+    return this.assertTopFrameAttachConstraint(frameDetails)
+      && this.assertUrlAttachConstraint(frameDetails);
+  }
+
+  /**
+   * Assert that the attached frame is a top frame.
+   * @param {Object} frameDetails
+   * @returns {boolean}
+   */
+  assertTopFrameAttachConstraint(frameDetails) {
+    return frameDetails.frameId === Pagemod.TOP_FRAME_ID;
+  }
+
+  /**
+   * Assert that the attached frame is a top frame.
+   * @param {Object} frameDetails
+   * @returns {boolean}
+   */
+  assertUrlAttachConstraint(frameDetails) {
+    const user = User.getInstance();
+    if (user.isValid()) {
+      return ParseWebIntegrationUrlService.test(frameDetails.url);
     }
-  });
-};
-exports.WebIntegration = WebIntegration;
+    return false;
+  }
+}
+
+export default new WebIntegration();

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

@@ -0,0 +1,119 @@
+/**
+ * Passbolt ~ Open source password manager for teams
+ * Copyright (c) 2022 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) 2022 Passbolt SA (https://www.passbolt.com)
+ * @license       https://opensource.org/licenses/AGPL-3.0 AGPL License
+ * @link          https://www.passbolt.com Passbolt(tm)
+ * @since         3.8.0
+ */
+import User from "../model/user";
+import UserSettings from "../model/userSettings/userSettings";
+import WebIntegration from "./webIntegrationPagemod";
+import WorkersSessionStorage from "../service/sessionStorage/workersSessionStorage";
+import WorkerEntity from "../model/entity/worker/workerEntity";
+import ScriptExecution from "../sdk/scriptExecution";
+import each from "jest-each";
+import Pagemod from "./pagemod";
+import {ConfigEvents} from "../event/configEvents";
+import {OrganizationSettingsEvents} from "../event/organizationSettingsEvents";
+import {WebIntegrationEvents} from "../event/webIntegrationEvents";
+import {PortEvents} from "../event/portEvents";
+
+const spyAddWorker = jest.spyOn(WorkersSessionStorage, "addWorker");
+jest.spyOn(ScriptExecution.prototype, "injectPortname").mockImplementation(jest.fn());
+jest.spyOn(ScriptExecution.prototype, "injectCss").mockImplementation(jest.fn());
+jest.spyOn(ScriptExecution.prototype, "injectJs").mockImplementation(jest.fn());
+jest.spyOn(ConfigEvents, "listen").mockImplementation(jest.fn());
+jest.spyOn(WebIntegrationEvents, "listen").mockImplementation(jest.fn());
+jest.spyOn(OrganizationSettingsEvents, "listen").mockImplementation(jest.fn());
+jest.spyOn(PortEvents, "listen").mockImplementation(jest.fn());
+
+describe("WebIntegration", () => {
+  beforeEach(async() => {
+    jest.resetModules();
+    jest.clearAllMocks();
+  });
+
+  describe("WebIntegration::injectFile", () => {
+    it("Should inject file", async() => {
+      expect.assertions(10);
+      // process
+      await WebIntegration.injectFiles(1, 0);
+      // expectations
+      expect(spyAddWorker).toHaveBeenCalledWith(expect.any(WorkerEntity));
+      expect(spyAddWorker).toHaveBeenCalledTimes(1);
+      expect(ScriptExecution.prototype.injectPortname).toHaveBeenCalledTimes(1);
+      expect(ScriptExecution.prototype.injectCss).toHaveBeenCalledWith(WebIntegration.contentStyleFiles);
+      expect(ScriptExecution.prototype.injectJs).toHaveBeenCalledWith(WebIntegration.contentScriptFiles);
+      expect(WebIntegration.contentStyleFiles).toStrictEqual([]);
+      expect(WebIntegration.contentScriptFiles).toStrictEqual(['contentScripts/js/dist/browser-integration/vendors.js', 'contentScripts/js/dist/browser-integration/browser-integration.js']);
+      expect(WebIntegration.events).toStrictEqual([ConfigEvents, WebIntegrationEvents, OrganizationSettingsEvents, PortEvents]);
+      expect(WebIntegration.mustReloadOnExtensionUpdate).toBeFalsy();
+      expect(WebIntegration.appName).toBe('WebIntegration');
+    });
+  });
+
+  describe("WebIntegration::canBeAttachedTo", () => {
+    it("Should be able to attach web integration pagemod to browser frame", async() => {
+      expect.assertions(1);
+      // mock functions
+      jest.spyOn(User.getInstance(), "isValid").mockImplementation(() => true);
+      jest.spyOn(UserSettings.prototype, "getDomain").mockImplementation(() => "https://passbolt.dev");
+      const result = await WebIntegration.canBeAttachedTo({frameId: 1, url: "https://test.dev/auth/login"});
+      expect(result).toBeFalsy();
+    });
+
+    each([
+      {scenario: "Passbolt domain", url: "https://passbolt.dev/auth/login", frameId: Pagemod.TOP_FRAME_ID},
+      {scenario: "No domain", url: "about:blank", frameId: 1},
+    ]).describe("Should not be able to attach a pagemod to browser frame", _props => {
+      it(`Should not be able to attach a pagemod to browser frame: ${_props.scenario}`, async() => {
+        expect.assertions(1);
+        // mock functions
+        jest.spyOn(User.getInstance(), "isValid").mockImplementation(() => true);
+        jest.spyOn(UserSettings.prototype, "getDomain").mockImplementation(() => "https://passbolt.dev");
+        const result = await WebIntegration.canBeAttachedTo({frameId: _props.frameId, url: _props.url});
+        expect(result).toBeFalsy();
+      });
+    });
+
+    it("Should have the constraint not valid if the user is not valid", async() => {
+      expect.assertions(1);
+      // mock functions
+      jest.spyOn(User.getInstance(), "isValid").mockImplementation(() => false);
+      // process
+      const result = await WebIntegration.canBeAttachedTo({frameId: 0});
+      // expectations
+      expect(result).toBeFalsy();
+    });
+  });
+
+  describe("WebIntegration::attachEvents", () => {
+    it("Should attach events", async() => {
+      expect.assertions(4);
+      // data mocked
+      const port = {
+        on: () => jest.fn(),
+        _port: {
+          sender: {
+            tab: {
+              url: "https://localhost"
+            }
+          }
+        }
+      };
+      // process
+      await WebIntegration.attachEvents(port);
+      // expectations
+      expect(ConfigEvents.listen).toHaveBeenCalledWith({port: port, tab: port._port.sender.tab, name: WebIntegration.appName});
+      expect(WebIntegrationEvents.listen).toHaveBeenCalledWith({port: port, tab: port._port.sender.tab, name: WebIntegration.appName});
+      expect(OrganizationSettingsEvents.listen).toHaveBeenCalledWith({port: port, tab: port._port.sender.tab, name: WebIntegration.appName});
+      expect(PortEvents.listen).toHaveBeenCalledWith({port: port, tab: port._port.sender.tab, name: WebIntegration.appName});
+    });
+  });
+});

package/src/all/background_page/sdk/i18n.js

@@ -0,0 +1,68 @@
+/**
+ * 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         3.2.0
+ */
+import i18next from "i18next";
+import HttpApi from "i18next-http-backend";
+
+/**
+ * The instance of the I18next library.
+ */
+let _i18next;
+
+class I18n {
+  /**
+   * Initialize I18n
+   * @param {string} locale The locale. i.e. en-UK
+   * @param {array<string>} supportedLocales The supported locales. i.e. ['en-UK', 'fr-FR']
+   */
+  static init(locale, supportedLocales) {
+    _i18next = i18next.createInstance();
+    _i18next.use(HttpApi)
+      .init({
+        lng: locale,
+        load: 'currentOnly',
+        backend: {
+          loadPath: '/locales/{{lng}}/{{ns}}.json'
+        },
+        supportedLngs: supportedLocales,
+        fallbackLng: false,
+        ns: ['common'],
+        defaultNS: 'common',
+        keySeparator: false, // don't use the dot for separator of nested json object
+        nsSeparator: false, // allowed ':' in key to avoid namespace separator
+        debug: false,
+      });
+  }
+
+  /**
+   * Initialize the library with the default locale.
+   */
+  static initWithDefaultLocale() {
+    const defaultLocale = "en-UK";
+    const defaultSupportedLocales = [defaultLocale];
+    I18n.init(defaultLocale, defaultSupportedLocales);
+  }
+
+  /**
+   * Interface to the i18next translation function t().
+   * @returns {string}
+   */
+  static t() {
+    if (!_i18next) {
+      I18n.initWithDefaultLocale();
+    }
+    return _i18next.t.apply(_i18next, arguments);
+  }
+}
+
+export default I18n;

package/src/all/background_page/sdk/port/portManager.js

@@ -0,0 +1,187 @@
+/**
+ * Passbolt ~ Open source password manager for teams
+ * Copyright (c) 2023 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) 2023 Passbolt SA (https://www.passbolt.com)
+ * @license       https://opensource.org/licenses/AGPL-3.0 AGPL License
+ * @link          https://www.passbolt.com Passbolt(tm)
+ * @since         4.0.0
+ */
+import Port from "../port";
+import PagemodManager from "../../pagemod/pagemodManager";
+import WorkersSessionStorage from "../../service/sessionStorage/workersSessionStorage";
+import WorkerEntity from "../../model/entity/worker/workerEntity";
+
+class PortManager {
+  constructor() {
+    this._ports = {}; // Object{portId: port, ...} for which the port is available
+    this.onPortConnect = this.onPortConnect.bind(this);
+    this.onTabRemoved = this.onTabRemoved.bind(this);
+  }
+
+  /**
+   * on port connect
+   * @param port the port
+   * @returns {Promise<void>}
+   */
+  async onPortConnect(port) {
+    if (await this.isQuickAccessPort(port.sender)) {
+      // Quickaccess is not stored in the session storage and there is no worker entity referenced
+      await this.registerAndAttachEvent(port, "QuickAccess");
+    } else {
+      await this.connectPortFromTab(port);
+    }
+  }
+
+  /**
+   * Connect port from tab
+   * @param port the port
+   * @returns {Promise<void>}
+   */
+  async connectPortFromTab(port) {
+    const worker = await WorkersSessionStorage.getWorkerById(port.name);
+    if (worker) {
+      const workerEntity = new WorkerEntity(worker);
+      /*
+       * If a port is already connected and is still in memory it should not be registered again
+       * In the MV3 case the memory is flushed when the servoce worker is down so the port should be able to reconnect
+       */
+      if (!this.isPortExist(port.name) && await this.isKnownPortSender(workerEntity, port.sender)) {
+        await this.updateWorkerStatus(workerEntity);
+        await this.registerAndAttachEvent(port, workerEntity.name);
+      } else {
+        console.debug(`A known port has been denied connection or reconnection with name=${port.name}, tabUrl=${port.sender.tab.url}, tabId=${port.sender.tab.id}, frameId=${port.sender.frameId}`);
+      }
+    } else {
+      // If there is no worker associate to this port
+      console.debug(`An unknown port has been denied connection with name=${port.name}, tabUrl=${port.sender.tab.url}, tabId=${port.sender.tab.id}, frameId=${port.sender.frameId}`);
+    }
+  }
+
+  /**
+   * Is quickAccess port sender
+   * @param sender
+   * @returns {Promise<boolean>}
+   */
+  async isQuickAccessPort(sender) {
+    if (sender.tab) {
+      // Tab property will only be present when the connection was opened from a tab
+      return false;
+    } else {
+      // The sender is a script running in an extension page
+      const popupUrl = await browser.action.getPopup({});
+      return sender.url === popupUrl;
+    }
+  }
+
+  /**
+   * Is known port sender
+   * @param {WorkerEntity} worker The worker
+   * @param sender The sender
+   * @returns {Promise<boolean>}
+   */
+  async isKnownPortSender(worker, sender) {
+    // Iframe application connecting for the first time are not know therefor their frame id is not yet associated
+    if (worker.frameId === null) {
+      worker.frameId = sender.frameId;
+    }
+    return worker.tabId === sender.tab.id && worker.frameId === sender.frameId;
+  }
+
+  /**
+   * Register and attach event to the port
+   * @param port The port
+   * @param {string} name The pagemod name
+   * @returns {Promise<void>}
+   */
+  async registerAndAttachEvent(port, name) {
+    const portWrapper = new Port(port);
+    this.registerPort(portWrapper);
+    await PagemodManager.attachEventToPort(portWrapper, name);
+    portWrapper.emit('passbolt.port.ready');
+  }
+
+  /**
+   * Update the worker status
+   * @param {WorkerEntity} worker The worker
+   * @return {Promise<void>}
+   */
+  async updateWorkerStatus(worker) {
+    worker.status = WorkerEntity.STATUS_CONNECTED;
+    await WorkersSessionStorage.updateWorker(worker);
+  }
+
+  /**
+   * Register the port
+   * @param port
+   */
+  registerPort(port) {
+    this._ports[port._port.name] = port;
+  }
+
+  /**
+   * Disconnect and remove the port
+   * @param {string} id the id
+   * @param {object} removeInfo The remove info
+   * @returns <void>
+   */
+  removePort(id, removeInfo = null) {
+    // The port will be disconnected automatically after a tab is removed
+    if (!removeInfo) {
+      // Disconnect the port manually when the user navigate to another page (browser will disconnect too late)
+      this._ports[id]?.disconnect();
+    }
+    delete this._ports[id];
+  }
+
+  /**
+   * Is port exist
+   * @param {string} id The id
+   * @returns {boolean}
+   */
+  isPortExist(id) {
+    return Boolean(this._ports[id]);
+  }
+
+  /**
+   * Get the port by id
+   * @param {string} id The id
+   * @returns {Port}
+   */
+  getPortById(id) {
+    return this._ports[id];
+  }
+
+  /**
+   * Flush.
+   * @returns {Promise<void>}
+   */
+  async flush() {
+    this._ports = {};
+    await WorkersSessionStorage.flush();
+  }
+
+  /**
+   * On tab removed, remove associated worker from the session storage and delete runtime ports references.
+   * @param {number} tabId The tab id
+   * @param {object} removeInfo The remove info (only present on tab on removed event)
+   * @returns {Promise<void>}
+   */
+  async onTabRemoved(tabId, removeInfo = null) {
+    if (typeof tabId === "undefined") {
+      throw new Error("A tab identifier is required.");
+    }
+    if (!Number.isInteger(tabId)) {
+      throw new Error("The tab identifier should be a valid integer.");
+    }
+    const workers = await WorkersSessionStorage.getWorkersByTabId(tabId);
+    workers.forEach(worker => this.removePort(worker.id, removeInfo));
+    await WorkersSessionStorage.deleteByTabId(tabId);
+  }
+}
+
+export default new PortManager();