ghost 4.13.0 → 4.16.0

package/core/server/services/mega/mega.js

@@ -17,7 +17,6 @@ const db = require('../../data/db');
 const models = require('../../models');
 const postEmailSerializer = require('./post-email-serializer');
 const {getSegmentsFromHtml} = require('./segment-parser');
-const labs = require('../../../shared/labs');
 
 // Used to listen to email.added and email.edited model events originally, I think to offload this - ideally would just use jobs now if possible
 const events = require('../../lib/common/events');
@@ -74,16 +73,15 @@ const getEmailData = async (postModel, options) => {
  * @param {Object} postModel - post model instance
  * @param {[string]} toEmails - member email addresses to send email to
  * @param {ValidAPIVersion} apiVersion - api version to be used when serializing email data
- * @param {ValidMemberSegment} memberSegment
+ * @param {ValidMemberSegment} [memberSegment]
  */
 const sendTestEmail = async (postModel, toEmails, apiVersion, memberSegment) => {
     let emailData = await getEmailData(postModel, {apiVersion});
     emailData.subject = `[Test] ${emailData.subject}`;
 
-    if (labs.isSet('emailCardSegments') && memberSegment) {
+    if (memberSegment) {
         emailData = postEmailSerializer.renderEmailForSegment(emailData, memberSegment);
     }
-
     // fetch any matching members so that replacements use expected values
     const recipients = await Promise.all(toEmails.map(async (email) => {
         const member = await membersService.api.members.get({email});
@@ -109,6 +107,14 @@ const sendTestEmail = async (postModel, toEmails, apiVersion, memberSegment) =>
         return Promise.reject(response.error);
     }
 
+    if (response && response[0] && response[0].error) {
+        return Promise.reject(new errors.EmailError({
+            statusCode: response[0].error.statusCode,
+            message: response[0].error.message,
+            context: response[0].error.originalMessage
+        }));
+    }
+
     return response;
 };
 
@@ -437,28 +443,26 @@ async function createSegmentedEmailBatches({emailModel, options}) {
         return [];
     }
 
-    if (labs.isSet('emailCardSegments')) {
-        const segments = getSegmentsFromHtml(emailModel.get('html'));
-        const batchIds = [];
-
-        if (segments.length) {
-            const partitionedMembers = partitionMembersBySegment(memberRows, segments);
-
-            for (const partition in partitionedMembers) {
-                const emailBatchIds = await createEmailBatches({
-                    emailModel,
-                    memberRows: partitionedMembers[partition],
-                    memberSegment: partition === 'unsegmented' ? null : partition,
-                    options
-                });
-                batchIds.push(emailBatchIds);
-            }
-            return batchIds;
+    const segments = getSegmentsFromHtml(emailModel.get('html'));
+    const batchIds = [];
+
+    if (segments.length) {
+        const partitionedMembers = partitionMembersBySegment(memberRows, segments);
+
+        for (const partition in partitionedMembers) {
+            const emailBatchIds = await createEmailBatches({
+                emailModel,
+                memberRows: partitionedMembers[partition],
+                memberSegment: partition === 'unsegmented' ? null : partition,
+                options
+            });
+            batchIds.push(emailBatchIds);
         }
+    } else {
+        const emailBatchIds = await createEmailBatches({emailModel, memberRows, options});
+        batchIds.push(emailBatchIds);
     }
 
-    const emailBatchIds = await createEmailBatches({emailModel, memberRows, options});
-    const batchIds = [emailBatchIds];
     return batchIds;
 }
 

package/core/server/services/mega/post-email-serializer.js

@@ -1,10 +1,8 @@
 const _ = require('lodash');
 const juice = require('juice');
 const template = require('./template');
-const labsTemplate = require('./template-labs');
 const settingsCache = require('../../../shared/settings-cache');
 const urlUtils = require('../../../shared/url-utils');
-const labs = require('../../../shared/labs');
 const moment = require('moment-timezone');
 const cheerio = require('cheerio');
 const api = require('../../api');
@@ -17,6 +15,30 @@ const logging = require('@tryghost/logging');
 
 const ALLOWED_REPLACEMENTS = ['first_name'];
 
+// Format a full html document ready for email by inlining CSS, adjusting links,
+// and performing any client-specific fixes
+const formatHtmlForEmail = function formatHtmlForEmail(html) {
+    const juiceOptions = {inlinePseudoElements: true};
+
+    let juicedHtml = juice(html, juiceOptions);
+
+    // convert juiced HTML to a DOM-like interface for further manipulation
+    // happens after inlining of CSS so we can change element types without worrying about styling
+    const _cheerio = cheerio.load(juicedHtml);
+
+    // force all links to open in new tab
+    _cheerio('a').attr('target', '_blank');
+    // convert figure and figcaption to div so that Outlook applies margins
+    _cheerio('figure, figcaption').each((i, elem) => !!(elem.tagName = 'div'));
+
+    juicedHtml = _cheerio.html();
+
+    // Fix any unsupported chars in Outlook
+    juicedHtml = juicedHtml.replace(/'/g, ''');
+
+    return juicedHtml;
+};
+
 const getSite = () => {
     const publicSettings = settingsCache.getPublic();
     return Object.assign({}, publicSettings, {
@@ -266,7 +288,7 @@ const serialize = async (postModel, options = {isBrowserPreview: false, apiVersi
 
     const templateSettings = await getTemplateSettings();
 
-    const render = labs.isSet('emailCardSegments') ? labsTemplate : template;
+    const render = template;
 
     let htmlTemplate = render({post, site: getSite(), templateSettings});
 
@@ -275,25 +297,9 @@ const serialize = async (postModel, options = {isBrowserPreview: false, apiVersi
         htmlTemplate = htmlTemplate.replace('%recipient.unsubscribe_url%', previewUnsubscribeUrl);
     }
 
-    // Inline css to style attributes, turn on support for pseudo classes.
-    const juiceOptions = {inlinePseudoElements: true};
-    let juicedHtml = juice(htmlTemplate, juiceOptions);
-
-    // convert juiced HTML to a DOM-like interface for further manipulation
-    // happens after inlining of CSS so we can change element types without worrying about styling
-    _cheerio = cheerio.load(juicedHtml);
-    // force all links to open in new tab
-    _cheerio('a').attr('target','_blank');
-    // convert figure and figcaption to div so that Outlook applies margins
-    _cheerio('figure, figcaption').each((i, elem) => !!(elem.tagName = 'div'));
-    juicedHtml = _cheerio.html();
-
-    // Fix any unsupported chars in Outlook
-    juicedHtml = juicedHtml.replace(/'/g, ''');
-
     // Clean up any unknown replacements strings to get our final content
     const {html, plaintext} = normalizeReplacementStrings({
-        html: juicedHtml,
+        html: formatHtmlForEmail(htmlTemplate),
         plaintext: post.plaintext
     });
 
@@ -316,7 +322,8 @@ function renderEmailForSegment(email, memberSegment) {
             $(node).removeAttr('data-gh-segment');
         }
     });
-    result.html = $.html();
+
+    result.html = formatHtmlForEmail($.html());
     result.plaintext = htmlToPlaintext(result.html);
 
     return result;

package/core/server/services/mega/template.js

@@ -576,6 +576,7 @@ figure blockquote p {
 .btn {
     box-sizing: border-box;
     width: 100%;
+    display: table;
 }
 
 .btn>tbody>tr>td {
@@ -618,6 +619,16 @@ figure blockquote p {
     color: #ffffff;
 }
 
+.btn-accent table td {
+    background-color: ${templateSettings.adjustedAccentColor || '#3498db'};
+}
+
+.btn-accent a {
+    background-color: ${templateSettings.adjustedAccentColor || '#3498db'};
+    border-color: ${templateSettings.adjustedAccentColor || '#3498db'};
+    color: ${templateSettings.adjustedAccentContrastColor || '#ffffff'};
+}
+
 /* -------------------------------------
     OTHER STYLES THAT MIGHT BE USEFUL
 ------------------------------------- */

package/core/server/services/members/api.js

@@ -176,6 +176,7 @@ function createApiInstance(config) {
             MemberPaymentEvent: models.MemberPaymentEvent,
             MemberStatusEvent: models.MemberStatusEvent,
             MemberProductEvent: models.MemberProductEvent,
+            MemberAnalyticEvent: models.MemberAnalyticEvent,
             StripeProduct: models.StripeProduct,
             StripePrice: models.StripePrice,
             Product: models.Product,

package/core/server/services/members/emails/signup.js

@@ -125,7 +125,7 @@ module.exports = ({siteTitle, email, url, accentColor = '#15212A', siteDomain, s
                                 <table border="0" cellpadding="0" cellspacing="0" style="border-collapse: separate; mso-table-lspace: 0pt; mso-table-rspace: 0pt; width: auto;">
                                   <tbody>
                                     <tr>
-                                      <td style="font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Helvetica, Arial, sans-serif, 'Apple Color Emoji', 'Segoe UI Emoji', 'Segoe UI Symbol'; font-size: 16px; vertical-align: top; background-color: ${accentColor}; border-radius: 5px; text-align: center;"> <a href="${url}" target="_blank" style="display: inline-block; color: #ffffff; background-color: ${accentColor}; border: solid 1px ${accentColor}; border-radius: 5px; box-sizing: border-box; cursor: pointer; text-decoration: none; font-size: 16px; font-weight: normal; margin: 0; padding: 9px 22px 10px; border-color: ${accentColor};">Activate my account</a> </td>
+                                      <td style="font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Helvetica, Arial, sans-serif, 'Apple Color Emoji', 'Segoe UI Emoji', 'Segoe UI Symbol'; font-size: 16px; vertical-align: top; background-color: ${accentColor}; border-radius: 5px; text-align: center;"> <a href="${url}" target="_blank" style="display: inline-block; color: #ffffff; background-color: ${accentColor}; border: solid 1px ${accentColor}; border-radius: 5px; box-sizing: border-box; cursor: pointer; text-decoration: none; font-size: 16px; font-weight: normal; margin: 0; padding: 9px 22px 10px; border-color: ${accentColor};">Confirm signup</a> </td>
                                     </tr>
                                   </tbody>
                                 </table>

package/core/server/services/oembed.js

@@ -101,8 +101,13 @@ class OEmbed {
         try {
             const cookieJar = new CookieJar();
             const response = await this.externalRequest(url, {cookieJar});
-            const html = response.body;
-            scraperResponse = await metascraper({html, url});
+
+            if (this.isIpOrLocalhost(response.url)) {
+                scraperResponse = {};
+            } else {
+                const html = response.body;
+                scraperResponse = await metascraper({html, url});
+            }
         } catch (err) {
             return Promise.reject(err);
         }

package/core/server/services/posts/post-scheduling-service.js

@@ -0,0 +1,100 @@
+const _ = require('lodash');
+const errors = require('@tryghost/errors');
+const moment = require('moment');
+const config = require('../../../shared/config');
+const urlUtils = require('../../../shared/url-utils');
+const api = require('../../api');
+
+const messages = {
+    jobNotFound: 'Job not found.',
+    jobPublishInThePast: 'Use the force flag to publish a post in the past.'
+};
+
+class PostSchedulingService {
+    /**
+     *
+     * @param {Object} options
+     * @param {String} options.apiVersion - api version
+     */
+    constructor({apiVersion}) {
+        this.api = api[apiVersion];
+    }
+
+    /**
+     * Publishes scheduled resource (a post or a page at the moment of writing)
+     *
+     * @param {String} resourceType one of 'post' or 'page' resources
+     * @param {String} id resource id
+     * @param {Boolean} force force publish flag
+     * @param {Object} options api query options
+     * @returns {Promise<Object, Object>}
+     */
+    async publish(resourceType, id, force, options) {
+        const publishAPostBySchedulerToleranceInMinutes = config.get('times').publishAPostBySchedulerToleranceInMinutes;
+
+        const result = await this.api[resourceType].read({id}, options);
+        const preScheduledResource = result[resourceType][0];
+
+        const publishedAtMoment = moment(preScheduledResource.published_at);
+
+        if (publishedAtMoment.diff(moment(), 'minutes') > publishAPostBySchedulerToleranceInMinutes) {
+            return Promise.reject(new errors.NotFoundError({message: messages.jobNotFound}));
+        }
+
+        if (publishedAtMoment.diff(moment(), 'minutes') < publishAPostBySchedulerToleranceInMinutes * -1 && force !== true) {
+            return Promise.reject(new errors.NotFoundError({message: messages.jobPublishInThePast}));
+        }
+
+        const editedResource = {};
+        editedResource[resourceType] = [{
+            status: 'published',
+            updated_at: moment(preScheduledResource.updated_at).toISOString(true)
+        }];
+
+        const editResult = await this.api[resourceType].edit(
+            editedResource,
+            _.pick(options, ['context', 'id', 'transacting', 'forUpdate'])
+        );
+        const scheduledResource = editResult[resourceType][0];
+
+        return {scheduledResource, preScheduledResource};
+    }
+
+    /**
+     *
+     * @param {Object} scheduledResource post or page resource object
+     * @param {Object} preScheduledResource post or page resource object in state before publishing
+     * @returns {Boolean|Object}
+     */
+    handleCacheInvalidation(scheduledResource, preScheduledResource) {
+        if (
+            (scheduledResource.status === 'published' && preScheduledResource.status !== 'published') ||
+            (scheduledResource.status === 'draft' && preScheduledResource.status === 'published')
+        ) {
+            return true;
+        } else if (
+            (scheduledResource.status === 'draft' && preScheduledResource.status !== 'published') ||
+            (scheduledResource.status === 'scheduled' && preScheduledResource.status !== 'scheduled')
+        ) {
+            return {
+                value: urlUtils.urlFor({
+                    relativeUrl: urlUtils.urlJoin('/p', scheduledResource.uuid, '/')
+                })
+            };
+        } else {
+            return false;
+        }
+    }
+}
+
+/**
+ * @param {string} apiVersion - API version to use within the service
+ * @returns {PostSchedulingService} instance of the PostsService
+ */
+const getPostSchedulingServiceInstance = (apiVersion) => {
+    return new PostSchedulingService({
+        apiVersion: apiVersion
+    });
+};
+
+module.exports = getPostSchedulingServiceInstance;

package/core/server/services/settings/index.js

@@ -5,22 +5,18 @@
 const events = require('../../lib/common/events');
 const models = require('../../models');
 const SettingsCache = require('../../../shared/settings-cache');
+const SettingsBREADService = require('./settings-bread-service');
+const {obfuscatedSetting, isSecretSetting, hideValueIfSecret} = require('./settings-utils');
 
-// The string returned when a setting is set as write-only
-const obfuscatedSetting = '••••••••';
-
-// The function used to decide whether a setting is write-only
-function isSecretSetting(setting) {
-    return /secret/.test(setting.key);
-}
-
-// The function that obfuscates a write-only setting
-function hideValueIfSecret(setting) {
-    if (setting.value && isSecretSetting(setting)) {
-        return {...setting, value: obfuscatedSetting};
-    }
-    return setting;
-}
+/**
+ * @returns {SettingsBREADService} instance of the PostsService
+ */
+const getSettingsBREADServiceInstance = () => {
+    return new SettingsBREADService({
+        SettingsModel: models.Settings,
+        settingsCache: SettingsCache
+    });
+};
 
 module.exports = {
     /**
@@ -74,5 +70,6 @@ module.exports = {
 
     obfuscatedSetting,
     isSecretSetting,
-    hideValueIfSecret
+    hideValueIfSecret,
+    getSettingsBREADServiceInstance
 };

package/core/server/services/settings/settings-bread-service.js

@@ -0,0 +1,188 @@
+const _ = require('lodash');
+const tpl = require('@tryghost/tpl');
+const {NotFoundError, NoPermissionError, BadRequestError} = require('@tryghost/errors');
+const {obfuscatedSetting, isSecretSetting, hideValueIfSecret} = require('./settings-utils');
+
+const messages = {
+    problemFindingSetting: 'Problem finding setting: {key}',
+    accessCoreSettingFromExtReq: 'Attempted to access core setting from external request'
+};
+
+class SettingsBREADService {
+    /**
+     *
+     * @param {Object} options
+     * @param {Object} options.SettingsModel
+     * @param {Object} options.settingsCache - SettingsCache instance
+     */
+    constructor({SettingsModel, settingsCache}) {
+        this.SettingsModel = SettingsModel;
+        this.settingsCache = settingsCache;
+    }
+
+    /**
+     *
+     * @param {Object} context ghost API context instance
+     * @returns
+     */
+    browse(context) {
+        let settings = this.settingsCache.getAll();
+
+        // CASE: no context passed (functional call)
+        if (!context) {
+            return Promise.resolve(settings.filter((setting) => {
+                return setting.group === 'site';
+            }));
+        }
+
+        if (!context.internal) {
+            // CASE: omit core settings unless internal request
+            settings = _.filter(settings, (setting) => {
+                const isCore = setting.group === 'core';
+                return !isCore;
+            });
+            // CASE: omit secret settings unless internal request
+            settings = settings.map(hideValueIfSecret);
+        }
+
+        return settings;
+    }
+
+    /**
+     *
+     * @param {String} key setting key
+     * @param {Object} [context] API context instance
+     * @returns {Object} an object with a filled out key that comes in a parameter
+     */
+    read(key, context) {
+        let setting;
+
+        if (key === 'slack') {
+            const slackURL = this.settingsCache.get('slack_url', {resolve: false});
+            const slackUsername = this.settingsCache.get('slack_username', {resolve: false});
+
+            setting = slackURL || slackUsername;
+            setting.key = 'slack';
+            setting.value = [{
+                url: slackURL && slackURL.value,
+                username: slackUsername && slackUsername.value
+            }];
+        } else {
+            setting = this.settingsCache.get(key, {resolve: false});
+        }
+
+        if (!setting) {
+            return Promise.reject(new NotFoundError({
+                message: tpl(messages.problemFindingSetting, {
+                    key: key
+                })
+            }));
+        }
+
+        // @TODO: handle in settings model permissible fn
+        if (setting.group === 'core' && !(context && context.internal)) {
+            return Promise.reject(new NoPermissionError({
+                message: tpl(messages.accessCoreSettingFromExtReq)
+            }));
+        }
+
+        setting = hideValueIfSecret(setting);
+
+        return {
+            [key]: setting
+        };
+    }
+
+    /**
+     *
+     * @param {Object[]} settings
+     * @param {Object} options
+     * @param {Object} [options.context]
+     * @param {Object} [stripeConnectData]
+     * @returns
+     */
+    async edit(settings, options, stripeConnectData) {
+        const filteredSettings = settings.filter((setting) => {
+            // The `stripe_connect_integration_token` "setting" is only used to set the `stripe_connect_*` settings.
+            return ![
+                'stripe_connect_integration_token',
+                'stripe_connect_publishable_key',
+                'stripe_connect_secret_key',
+                'stripe_connect_livemode',
+                'stripe_connect_account_id',
+                'stripe_connect_display_name'
+            ].includes(setting.key)
+                // Remove obfuscated settings
+                && !(setting.value === obfuscatedSetting && isSecretSetting(setting));
+        });
+
+        const getSetting = setting => this.settingsCache.get(setting.key, {resolve: false});
+
+        const firstUnknownSetting = filteredSettings.find(setting => !getSetting(setting));
+
+        if (firstUnknownSetting) {
+            throw new NotFoundError({
+                message: tpl(messages.problemFindingSetting, {
+                    key: firstUnknownSetting.key
+                })
+            });
+        }
+
+        if (!(options.context && options.context.internal)) {
+            const firstCoreSetting = filteredSettings.find(setting => getSetting(setting).group === 'core');
+
+            if (firstCoreSetting) {
+                throw new NoPermissionError({
+                    message: tpl(messages.accessCoreSettingFromExtReq)
+                });
+            }
+        }
+
+        if (stripeConnectData) {
+            filteredSettings.push({
+                key: 'stripe_connect_publishable_key',
+                value: stripeConnectData.public_key
+            });
+            filteredSettings.push({
+                key: 'stripe_connect_secret_key',
+                value: stripeConnectData.secret_key
+            });
+            filteredSettings.push({
+                key: 'stripe_connect_livemode',
+                value: stripeConnectData.livemode
+            });
+            filteredSettings.push({
+                key: 'stripe_connect_display_name',
+                value: stripeConnectData.display_name
+            });
+            filteredSettings.push({
+                key: 'stripe_connect_account_id',
+                value: stripeConnectData.account_id
+            });
+        }
+
+        return this.SettingsModel.edit(filteredSettings, options);
+    }
+
+    /**
+     *
+     * @param {Object} stripeConnectIntegrationToken
+     * @param {Function} getSessionProp sync function fetching property from session store
+     * @param {Function} getStripeConnectTokenData async function retreiving Stripe Connect data for settings
+     * @returns {Promise<Object>} resolves with an object with following keys: public_key, secret_key, livemode, display_name, account_id
+     */
+    async getStripeConnectData(stripeConnectIntegrationToken, getSessionProp, getStripeConnectTokenData) {
+        if (stripeConnectIntegrationToken && stripeConnectIntegrationToken.value) {
+            try {
+                return await getStripeConnectTokenData(stripeConnectIntegrationToken.value, getSessionProp);
+            } catch (err) {
+                throw new BadRequestError({
+                    err,
+                    message: 'The Stripe Connect token could not be parsed.'
+                });
+            }
+        }
+    }
+}
+
+module.exports = SettingsBREADService;

package/core/server/services/settings/settings-utils.js

@@ -0,0 +1,32 @@
+// The string returned when a setting is set as write-only
+const obfuscatedSetting = '••••••••';
+
+/**
+ * @description // The function used to decide whether a setting is write-only
+ * @param {Object} setting setting record
+ * @param {String} setting.key
+ * @returns {Boolean}
+ */
+function isSecretSetting(setting) {
+    return /secret/.test(setting.key);
+}
+
+/**
+ * @description The function that obfuscates a write-only setting
+ * @param {Object} setting setting record
+ * @param {String} setting.value
+ * @param {String} setting.key
+ * @returns {Object} settings record with obfuscated value if it's a secret
+ */
+function hideValueIfSecret(setting) {
+    if (setting.value && isSecretSetting(setting)) {
+        return {...setting, value: obfuscatedSetting};
+    }
+    return setting;
+}
+
+module.exports = {
+    obfuscatedSetting,
+    isSecretSetting,
+    hideValueIfSecret
+};

package/core/server/services/themes/ThemeStorage.js

@@ -60,8 +60,8 @@ class ThemeStorage extends LocalFileStorage {
     /**
      * Rename a file / folder
      *
-     *
-     * @param String fileName
+     * @param {String} srcName
+     * @param {String} destName
      */
     rename(srcName, destName) {
         let src = path.join(this.getTargetDir(), srcName);
@@ -71,9 +71,10 @@ class ThemeStorage extends LocalFileStorage {
     }
 
     /**
-     * Rename a file / folder
+     * Remove a file / folder
      *
-     * @param String backupName
+     * @param {String} fileName
+     * @returns {Promise<void>}
      */
     delete(fileName) {
         return fs.remove(path.join(this.getTargetDir(), fileName));

package/core/server/services/themes/activation-bridge.js

@@ -1,5 +1,7 @@
 const debug = require('@tryghost/debug')('themes');
 const bridge = require('../../../bridge');
+const labs = require('../../../shared/labs');
+const customThemeSettings = require('../custom-theme-settings');
 
 /**
  * These helper methods mean that the bridge is only required in one place
@@ -8,14 +10,26 @@ const bridge = require('../../../bridge');
 module.exports = {
     activateFromBoot: (themeName, theme, checkedTheme) => {
         debug('Activating theme (method A on boot)', themeName);
+        // TODO: probably a better place for this to happen - after successful activation / when reloading site?
+        if (labs.isSet('customThemeSettings')) {
+            customThemeSettings.activateTheme(checkedTheme);
+        }
         bridge.activateTheme(theme, checkedTheme);
     },
     activateFromAPI: (themeName, theme, checkedTheme) => {
         debug('Activating theme (method B on API "activate")', themeName);
+        // TODO: probably a better place for this to happen - after successful activation / when reloading site?
+        if (labs.isSet('customThemeSettings')) {
+            customThemeSettings.activateTheme(checkedTheme);
+        }
         bridge.activateTheme(theme, checkedTheme);
     },
     activateFromAPIOverride: (themeName, theme, checkedTheme) => {
         debug('Activating theme (method C on API "override")', themeName);
+        // TODO: probably a better place for this to happen - after successful activation / when reloading site?
+        if (labs.isSet('customThemeSettings')) {
+            customThemeSettings.activateTheme(checkedTheme);
+        }
         bridge.activateTheme(theme, checkedTheme);
     }
 };

package/core/server/services/themes/index.js

@@ -2,6 +2,7 @@ const activate = require('./activate');
 const themeLoader = require('./loader');
 const storage = require('./storage');
 const getJSON = require('./to-json');
+const installer = require('./installer');
 
 const settingsCache = require('../../../shared/settings-cache');
 
@@ -26,6 +27,7 @@ module.exports = {
         activate: activate.activate,
         getZip: storage.getZip,
         setFromZip: storage.setFromZip,
+        installFromGithub: installer.installFromGithub,
         destroy: storage.destroy
     }
 };