411 lines
10 KiB
JavaScript
411 lines
10 KiB
JavaScript
const {exec} = require('child_process')
|
|
const {resolve, basename} = require('path')
|
|
const {writeFileSync} = require('fs')
|
|
const State = require('./renderer/lib/state')
|
|
|
|
const {app, dialog} = require('electron')
|
|
const {sync: mkdirpSync} = require('mkdirp')
|
|
const ms = require('ms')
|
|
const shellEnv = require('shell-env')
|
|
const crypto = require('crypto')
|
|
|
|
const config = require('./config')
|
|
|
|
module.exports = class Plugins {
|
|
constructor () {
|
|
// modules path
|
|
this.path = resolve(config.getConfigPath(), 'plugins')
|
|
log('path: ', this.path)
|
|
this.availableExtensions = new Set([
|
|
'onApp', 'onWindow', 'onRendererWindow', 'onUnload', 'middleware',
|
|
'reduceUI', 'reduceSessions', 'reduceTermGroups',
|
|
'decorateMenu', 'decorateTerm', 'decorateWindow',
|
|
'decorateTab', 'decorateNotification', 'decorateNotifications',
|
|
'decorateTabs', 'decorateConfig', 'decorateEnv',
|
|
'decorateTermGroup', 'getTermProps',
|
|
'getTabProps', 'getTabsProps', 'getTermGroupProps',
|
|
'mapTermsState', 'mapHeaderState', 'mapNotificationsState',
|
|
'mapTermsDispatch', 'mapHeaderDispatch', 'mapNotificationsDispatch'
|
|
])
|
|
|
|
this.forceUpdate = false
|
|
this.updating = false
|
|
this.watchers = []
|
|
}
|
|
|
|
init (state) {
|
|
this.state = state
|
|
|
|
// initialize state
|
|
this.state.saved = Object.assign(this.state.saved || {})
|
|
|
|
// init plugin directories if not present
|
|
mkdirpSync(this.path)
|
|
|
|
// caches
|
|
this.plugins = config.getPlugins()
|
|
this.paths = this.getPaths(this.plugins)
|
|
this.id = this.getId(this.plugins)
|
|
this.modules = this.requirePlugins()
|
|
|
|
// we listen on configuration updates to trigger
|
|
// plugin installation
|
|
config.subscribe(() => {
|
|
const plugins = config.getPlugins()
|
|
if (plugins !== this.plugins) {
|
|
const id = this.getId(plugins)
|
|
if (this.id !== id) {
|
|
log('UPDATING...')
|
|
this.id = id
|
|
this.plugins = plugins
|
|
this.paths = this.getPaths(this.plugins)
|
|
this.updatePlugins()
|
|
}
|
|
}
|
|
})
|
|
|
|
// schedule the initial plugins update
|
|
// a bit after the user launches the app
|
|
// to prevent slowness
|
|
if (this.needsUpdate()) {
|
|
setTimeout(() => {
|
|
this.updatePlugins()
|
|
}, 5000)
|
|
log('installation scheduled')
|
|
}
|
|
|
|
// update plugins every 5 hours
|
|
setInterval(this.updatePlugins, ms('5h'))
|
|
}
|
|
|
|
didPluginsChange () {
|
|
return this.state.saved.installedPlugins !== this.id
|
|
}
|
|
|
|
hasPlugins () {
|
|
return !this.isEmptyObject(this.plugins)
|
|
}
|
|
|
|
isFirstInstall () {
|
|
return (!this.state.saved.installedPlugins && this.hasPlugins())
|
|
}
|
|
|
|
needsUpdate () {
|
|
return (this.didPluginsChange() || this.isFirstInstall())
|
|
}
|
|
|
|
getId (plugins) {
|
|
const hash = crypto.createHash('sha256');
|
|
hash.update(JSON.stringify(plugins));
|
|
return hash.digest('hex')
|
|
}
|
|
|
|
updatePlugins (forceUpdate = false) {
|
|
this.forceUpdate = forceUpdate
|
|
if (this.updating) {
|
|
// TODO
|
|
// return notify('Plugin update in progress')
|
|
}
|
|
this.updating = true
|
|
this.syncPackageJSON()
|
|
this.installPackages((err) => this.loadPlugins(err))
|
|
}
|
|
|
|
loadPlugins (err, localOnly = false) {
|
|
this.updating = false
|
|
|
|
// handle errors first
|
|
if (err) {
|
|
console.error(err.stack)
|
|
if (/not a recognized/.test(err.message) || /command not found/.test(err.message)) {
|
|
this.alert(
|
|
'Error updating plugins: We could not find the "npm" command. Make sure it\'s in $PATH'
|
|
)
|
|
return
|
|
}
|
|
|
|
this.alert(
|
|
'Error updating plugins: Check `${this.path}/npm-debug.log` for more information.'
|
|
)
|
|
return
|
|
}
|
|
|
|
// update state with latest plugins
|
|
this.state.saved.plugins = this.plugins
|
|
|
|
// cache modules
|
|
this.modules = this.requirePlugins()
|
|
|
|
// clear require cache
|
|
this.clearCache()
|
|
|
|
// we're done with local plugins
|
|
if (localOnly) return
|
|
|
|
// OK, no errors
|
|
// flag successful plugin update
|
|
this.state.saved.installedPlugins = this.id
|
|
|
|
// check if package based plugins were updated
|
|
const loaded = this.modules.length
|
|
const total = this.paths.plugins.length
|
|
const pluginVersions = JSON.stringify(this.getPluginVersions())
|
|
const changed = this.state.saved.installedPluginVersions !== pluginVersions && loaded === total
|
|
this.state.saved.installedPluginVersions = pluginVersions
|
|
|
|
// notify watchers
|
|
if (this.forceUpdate || changed) {
|
|
this.watchers.forEach(fn => fn(err, {forceUpdate: this.forceUpdate}))
|
|
log('instalation completed')
|
|
}
|
|
|
|
// save state
|
|
State.save(this.state)
|
|
}
|
|
|
|
getPluginVersions () {
|
|
const paths_ = this.paths.plugins
|
|
return paths_.map(path => {
|
|
let version = null
|
|
try {
|
|
// eslint-disable-next-line import/no-dynamic-require
|
|
version = require(resolve(path, 'package.json')).version
|
|
} catch (err) { }
|
|
return [
|
|
basename(path),
|
|
version
|
|
]
|
|
})
|
|
}
|
|
|
|
clearCache () {
|
|
// trigger unload hooks
|
|
this.modules.forEach(mod => {
|
|
if (mod.onUnload) {
|
|
mod.onUnload(app)
|
|
}
|
|
})
|
|
|
|
// clear require cache
|
|
for (const entry in require.cache) {
|
|
if (entry.indexOf(this.path) === 0) {
|
|
delete require.cache[entry]
|
|
}
|
|
}
|
|
}
|
|
|
|
isEmptyObject (obj) {
|
|
return (Object.keys(obj).length === 0)
|
|
}
|
|
|
|
syncPackageJSON () {
|
|
const dependencies = this.toDependencies(this.plugins)
|
|
const pkg = {
|
|
name: 'webtorrent-plugins',
|
|
description: 'Auto-generated from WebTorrent config.',
|
|
private: true,
|
|
version: '0.0.1',
|
|
repository: 'feross/webtorrent-desktop',
|
|
license: 'MIT',
|
|
homepage: 'https://webtorrent.io',
|
|
dependencies
|
|
}
|
|
|
|
const file = resolve(this.path, 'package.json')
|
|
try {
|
|
writeFileSync(file, JSON.stringify(pkg, null, 2))
|
|
return true
|
|
} catch (err) {
|
|
this.alert(`An error occurred writing to ${file}`)
|
|
}
|
|
}
|
|
|
|
alert (message) {
|
|
log(message)
|
|
// TODO: display notifications
|
|
// dialog.showMessageBox({
|
|
// message,
|
|
// buttons: ['Ok']
|
|
// })
|
|
}
|
|
|
|
isLocalPath (string) {
|
|
// matches unix and windows local paths
|
|
return string.match(/^(\/|[a-z]:\/)/i)
|
|
}
|
|
|
|
toDependencies (plugins) {
|
|
const obj = {}
|
|
const pluginNames = Object.keys(plugins)
|
|
|
|
pluginNames.forEach(name => {
|
|
let url = plugins[name]
|
|
if (this.isLocalPath(url)) return
|
|
obj[name] = url
|
|
})
|
|
return obj
|
|
}
|
|
|
|
installPackages (fn) {
|
|
const {shell = '', npmRegistry} = config
|
|
|
|
shellEnv(shell).then(env => {
|
|
if (npmRegistry) {
|
|
env.NPM_CONFIG_REGISTRY = npmRegistry
|
|
}
|
|
/* eslint-disable camelcase */
|
|
env.npm_config_runtime = 'electron'
|
|
env.npm_config_target = process.versions.electron
|
|
env.npm_config_disturl = 'https://atom.io/download/atom-shell'
|
|
/* eslint-enable camelcase */
|
|
// Shell-specific installation commands
|
|
const installCommands = {
|
|
fish: 'npm prune; and npm install --production',
|
|
posix: 'npm prune && npm install --production'
|
|
}
|
|
// determine the shell we're running in
|
|
const whichShell = shell.match(/fish/) ? 'fish' : 'posix'
|
|
|
|
// Use the install command that is appropriate for our shell
|
|
exec(installCommands[whichShell], {
|
|
cwd: this.path//,
|
|
// env,
|
|
// shell
|
|
}, err => {
|
|
if (err) {
|
|
return fn(err)
|
|
}
|
|
fn(null)
|
|
})
|
|
}).catch(fn)
|
|
}
|
|
|
|
subscribe (fn) {
|
|
this.watchers.push(fn)
|
|
return () => {
|
|
this.watchers.splice(this.watchers.indexOf(fn), 1)
|
|
}
|
|
}
|
|
|
|
getPaths (plugins) {
|
|
const pluginNames = Object.keys(plugins)
|
|
|
|
return {
|
|
plugins: pluginNames.map(name => {
|
|
let url = plugins[name]
|
|
|
|
// plugin is already on a local folder
|
|
// directly load it from its current location
|
|
if (this.isLocalPath(url)) return url
|
|
|
|
// plugin will be installed with npm install from a remote url
|
|
return resolve(this.path, 'node_modules', name.split('#')[0])
|
|
})
|
|
}
|
|
}
|
|
|
|
requirePlugins () {
|
|
const {plugins} = this.paths
|
|
let installNeeded = false
|
|
|
|
const load = (path) => {
|
|
let mod
|
|
try {
|
|
// eslint-disable-next-line import/no-dynamic-require
|
|
mod = require(path)
|
|
const exposed = mod && Object.keys(mod).some(key => this.availableExtensions.has(key))
|
|
if (!exposed) {
|
|
this.alert(`Plugin error: Plugin "${basename(path)}" does not expose any ` +
|
|
'WebTorrent extension API methods')
|
|
return
|
|
}
|
|
|
|
// populate the name for internal errors here
|
|
mod._name = basename(path)
|
|
|
|
return mod
|
|
} catch (err) {
|
|
// plugin not installed
|
|
// node_modules removed? did a manual plugin uninstall?
|
|
// try installing and then loading if successfull
|
|
installNeeded = true
|
|
}
|
|
}
|
|
|
|
if (installNeeded) this.updatePlugins()
|
|
|
|
return plugins.map(load)
|
|
.filter(v => Boolean(v))
|
|
}
|
|
|
|
onApp (app) {
|
|
this.modules.forEach(plugin => {
|
|
if (plugin.onApp) {
|
|
plugin.onApp(app)
|
|
}
|
|
})
|
|
}
|
|
|
|
onWindow (win) {
|
|
this.modules.forEach(plugin => {
|
|
if (plugin.onWindow) {
|
|
plugin.onWindow(win)
|
|
}
|
|
})
|
|
}
|
|
|
|
// decorates the base object by calling plugin[key]
|
|
// for all the available plugins
|
|
decorateObject (base, key) {
|
|
let decorated = base
|
|
this.modules.forEach(plugin => {
|
|
if (plugin[key]) {
|
|
const res = plugin[key](decorated)
|
|
if (res && typeof res === 'object') {
|
|
decorated = res
|
|
} else {
|
|
this.alert(`Plugin error: "${plugin._name}": invalid return type for \`${key}\``)
|
|
}
|
|
}
|
|
})
|
|
|
|
return decorated
|
|
}
|
|
|
|
decorateMenu (tpl) {
|
|
return this.decorateObject(tpl, 'decorateMenu')
|
|
}
|
|
|
|
decorateWindow (options) {
|
|
return this.decorateObject(options, 'decorateWindow')
|
|
}
|
|
|
|
getDecoratedEnv (baseEnv) {
|
|
return this.decorateObject(baseEnv, 'decorateEnv')
|
|
}
|
|
|
|
getDecoratedConfig () {
|
|
const baseConfig = config.getConfig()
|
|
return this.decorateObject(baseConfig, 'decorateConfig')
|
|
}
|
|
|
|
getDecoratedBrowserOptions (defaults) {
|
|
return this.decorateObject(defaults, 'decorateBrowserOptions')
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Logs passed arguments to console using a prefix.
|
|
*
|
|
*/
|
|
function log() {
|
|
const prefix = '[ PLUGINS ]-->'
|
|
const args = [prefix]
|
|
|
|
for (var i=0; i<arguments.length; ++i) {
|
|
args.push(arguments[i])
|
|
}
|
|
|
|
console.log.apply(console, args)
|
|
}
|