How to create electron auto updates using private github repository?

Question

The update is being detected but I'm unable to download it to my app. I get the following error:

Status: Update Available
Status: Error in auto-updater. Error: Cannot download "https://api.github.com/repos/[username]/[repo-name]/releases/assets/15151663", status 404: Not Found.

The problem appears only using private github repository not public!!

I've tried installing auto updates to a clean electron react-boilerplate and it works perfectly fine with private github repository.. So i'm a bit at a loss what to do here..

I did some research and it seems like app-update.yml should contain github token (electron-builder should generate it) but my app-update.yml (which is located in release/win-unpacked/resources) does not contain a token...

It only contains this info:

owner: [username]
repo: [repo-name]
provider: github
updaterCacheDirName: [appname]

How can I generate it?

Other comment states that I should have a separate release-only repository which I do, but it still doesn't work.

Electron Autoupdater with Private GitHub Repository?

Other people say that downgrading versions fix this problem, but I also saw people say that doesn't fix it and downgrading isn't really a good option.

My steps of adding gh-token:

I setup my github info in package.json (this token is being ignored)

"publish": {
  "provider": "github",
  "owner": "[username]",
  "repo": "[repo-name]",
  "token": "[gh-token]",
  "private": true
}

"repository": {
  "type": "git",
  "url": "https://github.com/[username]/[repo-name].git"
},

So I add it to my main.js aswell just in case.

autoUpdater.setFeedURL({
  provider: 'github',
  repo: '[repo-name]',
  owner: '[username]',
  private: true,
  token: '[gh-token]'
});

process.env.GH_TOKEN = "[gh-token]";

When I remove setFeedURL I get the exact same error as in this questions: https://github.com/electron-userland/electron-builder/issues/2641

latest.yml (generated file in github releases along side installer.exe installer.exe.blockmap and installer.msi)

version: [version-number]
files:
  - url: [app-name.exe]
    sha512: [string]
    size: [file-size]
path: [app-name.exe]
sha512: [string]
releaseDate: [release-date]

versions i'm using:

"electron": "^3.0.10",
"electron-builder": "^20.38.4",
"electron-updater": "^4.0.0",

full main.js

import { app, BrowserWindow, ipcMain, dialog } from 'electron';
import { autoUpdater } from 'electron-updater';
import log from 'electron-log';
import MenuBuilder from './menu';

 export default class AppUpdater {
  constructor() {
     log.transports.file.level = 'info';
     autoUpdater.logger = log;
     autoUpdater.checkForUpdatesAndNotify();
  }
}

let mainWindow = null;

autoUpdater.setFeedURL({
  provider: 'github',
  repo: '[repo-name]',
  owner: '[username]',
  private: true,
  token: '[gh-token]'
});

process.env.GH_TOKEN = "[gh-token]";

if (process.env.NODE_ENV === 'production') {
  const sourceMapSupport = require('source-map-support');
  sourceMapSupport.install();
}

if (
  process.env.NODE_ENV === 'development' ||
  process.env.DEBUG_PROD === 'true'
) {
  require('electron-debug')();
}

const installExtensions = async () => {
  const installer = require('electron-devtools-installer');
  const forceDownload = !!process.env.UPGRADE_EXTENSIONS;
  const extensions = ['REACT_DEVELOPER_TOOLS', 'REDUX_DEVTOOLS'];

  return Promise.all(
    extensions.map(name => installer.default(installer[name], forceDownload))
  ).catch(console.log);
};

app.on('window-all-closed', () => {
  if (process.platform !== 'darwin') {
    app.quit();
  }
});

const sendStatusToWindow = (text) => {
  log.info(text);
  if(mainWindow){
    mainWindow.webContents.send('message', text);
  }
}

autoUpdater.on('checking-for-update', () => {
  sendStatusToWindow('Checking for update...');
});

autoUpdater.on('update-available', (info) => {
  sendStatusToWindow('Update available.');
  dialog.showMessageBox({
    message: 'update available !!'
  });
});

autoUpdater.on('update-not-available', (info) => {
  sendStatusToWindow('Update not available.');
});

autoUpdater.on('error', (err) => {
  sendStatusToWindow('Error in auto-updater. ' + err);
});

autoUpdater.on('download-progress', (progressObj) => {
  let log_message = "Download speed: " + progressObj.bytesPerSecond;
  log_message = log_message + ' - Downloaded ' + progressObj.percent + '%';
  log_message = log_message + ' (' + progressObj.transferred + "/" +     progressObj.total + ')';
  sendStatusToWindow(log_message);
})

autoUpdater.on('update-downloaded', (info) => {
  sendStatusToWindow('Update downloaded');

  dialog.showMessageBox({
    message: 'Update downloaded, restarting app..'
  });

  autoUpdater.quitAndInstall(); 
});

app.on('ready', async () => {

  autoUpdater.checkForUpdatesAndNotify();

  if (
    process.env.NODE_ENV === 'development' ||
    process.env.DEBUG_PROD === 'true'
  ) {
    await installExtensions();
  }

  mainWindow = new BrowserWindow({
    show: false,
    width: 1024,
    height: 728
  });

  mainWindow.webContents.openDevTools();

  mainWindow.loadURL(`file://${__dirname}/app.html`);

  mainWindow.webContents.on('did-finish-load', () => {
    if (!mainWindow) {
      throw new Error('"mainWindow" is not defined');
    }
    if (process.env.START_MINIMIZED) {
      mainWindow.minimize();
    } else {
      mainWindow.show();
      mainWindow.focus();
    }
  });

  mainWindow.on('closed', () => {
    mainWindow = null;
  });

  const menuBuilder = new MenuBuilder(mainWindow);
  menuBuilder.buildMenu();

  new AppUpdater();
});

I package my app using:

"package": "yarn build && electron-builder build --publish never"

And then I publish it to github releases using:

"gh-publish": "electron-builder --x64 -p always"

Answer 1

For anyone looking for an answer about this issue, I managed to download the update from my private Github repository by configuring my electron-builder options with :

win: {
   publish: [{
      private: true,
      provider: "github",
      releaseType: 'prerelease'
   }],
   target: 'nsis',
   icon: 'icons/icon.ico'
},

(It is defined in quasar.config.js because I am using the Quasar Framework, but it should work with a package.json config)

And then, In my updater code when my app run in production mode in the electron-main process, I use :

autoUpdater.addAuthHeader(`token ${process.env.GH_TOKEN}`);

(I have set the GH_TOKEN as an environment variable on my machine, but It should work anyway you pass the env var to the process on building or on execute)

Answer 2

import {autoUpdater} from 'electron-updater';   
 autoUpdater.setFeedURL({
          provider: 'github',
          owner: 'your_username',
          repo: 'your_repo_name',
          private: true,
          token: process.env.GH_TOKEN, // provide your github access token, with repo:access
        });

For the reference to pulling the update, look into this repo: https://github.com/iffy/electron-updater-example