implamenting the electron-chrome-web-store package in my app isent working

[IroniumStudios]

i treid implamenting your example in the application.ts where my app initializes, but when I did, I went to the chrome web store with my implementation of electron-chrome-extensions and it still says I need to install chrome to install extensions

here's my implementation

import { app, ipcMain, Menu, BrowserWindow, session } from 'electron';
import { isAbsolute, extname } from 'path';
import { existsSync } from 'fs';
import { SessionsService } from './sessions-service';
import { checkFiles } from '~/utils/files';
import { Settings } from './models/settings';
import { isURL, prefixHttp } from '~/utils';
import { WindowsService } from './windows-service';
import { StorageService } from './services/storage';
import { getMainMenu } from './menus/main';
import { runAutoUpdaterService } from './services';
import { DialogsService } from './services/dialogs-service';
import { requestAuth } from './dialogs/auth';
import { NetworkServiceHandler } from './network/network-service-handler';
import { ExtensionServiceHandler } from './extension-service-handler';
import { runDefaultBrowserService } from './services';
import { setupChromeWebStore } from 'electron-chrome-web-store'; // <-- Importing the package

export class Application {
  public static instance = new Application();

  public sessions: SessionsService;
  public settings: Settings;
  public storage: StorageService;
  public windows: WindowsService;
  public dialogs = new DialogsService();

  public async start() {
    const gotTheLock = app.requestSingleInstanceLock();

    if (!gotTheLock) {
      app.quit();
      return;
    } else {
      app.on('open-url', async (_, url) => {
        if (!this.windows.current) {
          this.windows.current = this.windows.open();
        }
        this.windows.current.win.focus();
        this.windows.current.viewManager.create({
          url: url,
          active: true,
        });
        this.windows.current.win.webContents.once('dom-ready', () => {
          this.windows.current.viewManager.create({
            url: url,
            active: true,
          });
        });
      });

      app.on('second-instance', async (e, argv) => {
        const path = argv[argv.length - 1];

        if (isAbsolute(path) && existsSync(path)) {
          if (process.env.NODE_ENV !== 'development') {
            const path = argv[argv.length - 1];
            const ext = extname(path);

            if (ext === '.html') {
              if (!this.windows.current) {
                this.windows.current = this.windows.open();
              }

              this.windows.current.win.focus();
              this.windows.current.viewManager.create({
                url: `file:///${path}`,
                active: true,
              });
              this.windows.current.win.webContents.once('dom-ready', () => {
                this.windows.current.viewManager.create({
                  url: `file:///${path}`,
                  active: true,
                });
              });
            }
          }
          return;
        } else if (isURL(path)) {
          if (!this.windows.current) {
            this.windows.current = this.windows.open();
          }

          this.windows.current.win.focus();
          this.windows.current.viewManager.create({
            url: prefixHttp(path),
            active: true,
          });
          this.windows.current.win.webContents.once('dom-ready', () => {
            this.windows.current.viewManager.create({
              url: prefixHttp(path),
              active: true,
            });
          });

          return;
        }

        this.windows.open();
      });
    }

    app.on('login', async (e, webContents, request, authInfo, callback) => {
      e.preventDefault();

      const window = this.windows.findByContentsView(webContents.id);
      const credentials = await requestAuth(
        window.win,
        request.url,
        webContents.id,
      );

      if (credentials) {
        callback(credentials.username, credentials.password);
      }
    });

    ipcMain.on('create-window', (e, incognito = false) => {
      this.windows.open(incognito);
    });

    await this.onReady();
  }

  private async onReady() {
    await app.whenReady();

    // Initialize the Extension Service Handler
    new ExtensionServiceHandler();

    // Handle the Chrome Web Store with the session
    const browserSession = session.defaultSession;
    setupChromeWebStore(browserSession);  // <-- Initialize Web Store setup

    NetworkServiceHandler.get();

    checkFiles();

    runDefaultBrowserService(app);

    this.sessions = new SessionsService();
    this.windows = new WindowsService(this.sessions);
    this.settings = new Settings();
    this.storage = new StorageService(this.settings);

    await this.storage.run();
    await this.dialogs.run();

    this.windows.open();

    Menu.setApplicationMenu(getMainMenu());
    runAutoUpdaterService();

    app.on('activate', () => {
      if (this.windows.list.filter((x) => x !== null).length === 0) {
        this.windows.open();
      }
    });

    const { object: webset } = Application.instance.settings;
    if (!webset.hardwareacceleration) {
      app.disableHardwareAcceleration();
    }
  }
}

here's the example I based the code off of

const { app, BrowserWindow, session } = require('electron')
const { setupChromeWebStore } = require('electron-chrome-web-store')

(async function main() {
  await app.whenReady()

  const browserSession = session.defaultSession
  const browserWindow = new BrowserWindow({
    webPreferences: {
      session: browserSession
    }
  })

  setupChromeWebStore(browserSession)

  browserWindow.loadURL('https://chromewebstore.google.com/')
}())

could you please help?

[samuelmaddock]

The Electron.Session passed to setupChromeWebStore needs to be the session used for browsing the web store. Is that the case for your browser?

Also, open the devtools to check that there are no errors in loading the preload. You can confirm it's working if chrome.webstorePrivate exists.

[IroniumStudios]

that is not the case, this code is for the app initialization