commit 00d65d605fc7c7ffd08caa84090f35196d1b8be1 · notnite.com/moonlight

+54 -7

packages/injector/src/index.ts

···

       24
       24
        
       let hasOpenAsar = false;

     

       25
       25
        
       let openAsarConfigPreload: string | undefined;

     

       26
       26
        
       

     

       27
       27
       +
       const scriptUrls = ["web.", "sentry."];

     

       28
       28
       +
       const blockedScripts = new Set<string>();

     

       29
       29
       +
       const replayedScripts = new Set<string>();

     

       30
       30
       +
       let blockingScripts = false;

     

       31
       31
       +
       let replayingScripts = false;

     

       32
       32
       +
       

     

       27
       33
        
       ipcMain.on(constants.ipcGetOldPreloadPath, (e) => {

     

       28
       34
        
         e.returnValue = oldPreloadPath;

     

       29
       35
        
       });

     

       36
       36
       +
       

     

       30
       37
        
       ipcMain.on(constants.ipcGetAppData, (e) => {

     

       31
       38
        
         e.returnValue = app.getPath("appData");

     

       32
       39
        
       });

     
···

       73
       80
        
       });

     

       74
       81
        
       

     

       75
       82
        
       function patchCsp(headers: Record<string, string[]>) {

     

       76
       76
       -
         const directives = ["style-src", "connect-src", "img-src", "font-src", "media-src", "worker-src", "prefetch-src"];

     

       77
       77
       -
         const values = ["*", "blob:", "data:", "'unsafe-inline'", "disclip:"];

     

       83
       83
       +
         const directives = [

     

       84
       84
       +
           "script-src",

     

       85
       85
       +
           "style-src",

     

       86
       86
       +
           "connect-src",

     

       87
       87
       +
           "img-src",

     

       88
       88
       +
           "font-src",

     

       89
       89
       +
           "media-src",

     

       90
       90
       +
           "worker-src",

     

       91
       91
       +
           "prefetch-src"

     

       92
       92
       +
         ];

     

       93
       93
       +
         const values = ["*", "blob:", "data:", "'unsafe-inline'", "'unsafe-eval'", "disclip:"];

     

       78
       94
        
       

     

       79
       95
        
         const csp = "content-security-policy";

     

       80
       96
        
         if (headers[csp] == null) return;

     
···

       110
       126
        
       

     

       111
       127
        
       class BrowserWindow extends ElectronBrowserWindow {

     

       112
       128
        
         constructor(opts: BrowserWindowConstructorOptions) {

     

       113
       113
       -
           oldPreloadPath = opts.webPreferences!.preload;

     

       114
       114
       -
       

     

       115
       129
        
           const isMainWindow = opts.webPreferences!.preload!.indexOf("discord_desktop_core") > -1;

     

       116
       130
        
       

     

       117
       117
       -
           if (isMainWindow) opts.webPreferences!.preload = require.resolve("./node-preload.js");

     

       131
       131
       +
           if (isMainWindow) {

     

       132
       132
       +
             if (!oldPreloadPath) oldPreloadPath = opts.webPreferences!.preload;

     

       133
       133
       +
             opts.webPreferences!.preload = require.resolve("./node-preload.js");

     

       134
       134
       +
           }

     

       118
       135
        
       

     

       119
       136
        
           // Event for modifying window options

     

       120
       137
        
           moonlightHost.events.emit("window-options", opts, isMainWindow);

     
···

       140
       157
        
             }

     

       141
       158
        
           });

     

       142
       159
        
       

     

       143
       143
       -
           // Allow plugins to block some URLs,

     

       144
       144
       -
           // this is needed because multiple webRequest handlers cannot be registered at once

     

       145
       160
        
           this.webContents.session.webRequest.onBeforeRequest((details, cb) => {

     

       161
       161
       +
             // Block scripts for node-preload kickoff

     

       162
       162
       +
             if (details.resourceType === "script" && isMainWindow) {

     

       163
       163
       +
               if (scriptUrls.some((url) => details.url.includes(url))) {

     

       164
       164
       +
                 if (!replayingScripts) {

     

       165
       165
       +
                   blockingScripts = true;

     

       166
       166
       +
                   blockedScripts.add(details.url);

     

       167
       167
       +
                 } else {

     

       168
       168
       +
                   replayedScripts.add(details.url);

     

       169
       169
       +
                   if (replayedScripts.size === scriptUrls.length) {

     

       170
       170
       +
                     replayingScripts = false;

     

       171
       171
       +
                     replayedScripts.clear();

     

       172
       172
       +
                   }

     

       173
       173
       +
                 }

     

       174
       174
       +
               }

     

       175
       175
       +
       

     

       176
       176
       +
               const shouldBlock = blockingScripts;

     

       177
       177
       +
       

     

       178
       178
       +
               if (blockedScripts.size === scriptUrls.length && blockingScripts) {

     

       179
       179
       +
                 setTimeout(() => {

     

       180
       180
       +
                   logger.debug("Kicking off node-preload");

     

       181
       181
       +
                   this.webContents.send(constants.ipcNodePreloadKickoff, Array.from(blockedScripts));

     

       182
       182
       +
                   blockingScripts = false;

     

       183
       183
       +
                   blockedScripts.clear();

     

       184
       184
       +
                   replayingScripts = true;

     

       185
       185
       +
                 }, 0);

     

       186
       186
       +
               }

     

       187
       187
       +
       

     

       188
       188
       +
               if (shouldBlock) return cb({ cancel: true });

     

       189
       189
       +
             }

     

       190
       190
       +
       

     

       191
       191
       +
             // Allow plugins to block some URLs,

     

       192
       192
       +
             // this is needed because multiple webRequest handlers cannot be registered at once

     

       146
       193
        
             cb({ cancel: blockedUrls.some((u) => u.test(details.url)) });

     

       147
       194
        
           });

     

       148
       195

+49 -6

packages/node-preload/src/index.ts

···

       13
       13
        
       import { getConfig, getConfigOption, getManifest, setConfigOption } from "@moonlight-mod/core/util/config";

     

       14
       14
        
       

     

       15
       15
        
       let initialized = false;

     

       16
       16
       +
       let logger: Logger;

     

       16
       17
        
       

     

       17
       18
        
       function setCors() {

     

       18
       19
        
         const data = getDynamicCors();

     
···

       35
       36
        
       

     

       36
       37
        
         let config = await readConfig();

     

       37
       38
        
         initLogger(config);

     

       39
       39
       +
         logger = new Logger("node-preload");

     

       40
       40
       +
       

     

       38
       41
        
         const extensions = await getExtensions();

     

       39
       42
        
         const processedExtensions = await loadExtensions(extensions);

     

       40
       43
        
         const moonlightDir = await getMoonlightDir();

     
···

       109
       112
        
         const webPreloadPath = path.join(__dirname, "web-preload.js");

     

       110
       113
        
         const webPreload = fs.readFileSync(webPreloadPath, "utf8");

     

       111
       114
        
         await webFrame.executeJavaScript(webPreload);

     

       115
       115
       +
       

     

       116
       116
       +
         const func = await webFrame.executeJavaScript("async () => { await window._moonlightBrowserLoad(); }");

     

       117
       117
       +
         await func();

     

       112
       118
        
       }

     

       113
       119
        
       

     

       114
       114
       -
       async function init(oldPreloadPath: string) {

     

       120
       120
       +
       async function init() {

     

       115
       121
        
         try {

     

       116
       122
        
           await injectGlobals();

     

       117
       123
        
           await loadPreload();

     
···

       122
       128
        
             message: message

     

       123
       129
        
           });

     

       124
       130
        
         }

     

       131
       131
       +
       }

     

       132
       132
       +
       

     

       133
       133
       +
       ipcRenderer.on(constants.ipcNodePreloadKickoff, (_, blockedScripts: string[]) => {

     

       134
       134
       +
         (async () => {

     

       135
       135
       +
           try {

     

       136
       136
       +
             await init();

     

       137
       137
       +
             logger.debug("Blocked scripts:", blockedScripts);

     

       138
       138
       +
       

     

       139
       139
       +
             const oldPreloadPath: string = ipcRenderer.sendSync(constants.ipcGetOldPreloadPath);

     

       140
       140
       +
             logger.debug("Old preload path:", oldPreloadPath);

     

       141
       141
       +
             if (oldPreloadPath) require(oldPreloadPath);

     

       142
       142
       +
       

     

       143
       143
       +
             // Do this to get global.DiscordNative assigned

     

       144
       144
       +
             // @ts-expect-error Lying to discord_desktop_core

     

       145
       145
       +
             process.emit("loaded");

     

       146
       146
       +
       

     

       147
       147
       +
             function replayScripts() {

     

       148
       148
       +
               const scripts = [...document.querySelectorAll("script")].filter(

     

       149
       149
       +
                 (script) => script.src && blockedScripts.some((url) => url.includes(script.src))

     

       150
       150
       +
               );

     

       125
       151
        
       

     

       126
       126
       -
         // Let Discord start even if we fail

     

       127
       127
       -
         if (oldPreloadPath) require(oldPreloadPath);

     

       128
       128
       -
       }

     

       152
       152
       +
               blockedScripts.reverse();

     

       153
       153
       +
               for (const url of blockedScripts) {

     

       154
       154
       +
                 const script = scripts.find((script) => url.includes(script.src))!;

     

       155
       155
       +
                 const newScript = document.createElement("script");

     

       156
       156
       +
                 for (const attr of script.attributes) {

     

       157
       157
       +
                   if (attr.name === "src") attr.value += "?inj";

     

       158
       158
       +
                   newScript.setAttribute(attr.name, attr.value);

     

       159
       159
       +
                 }

     

       160
       160
       +
                 script.remove();

     

       161
       161
       +
                 document.documentElement.appendChild(newScript);

     

       162
       162
       +
               }

     

       163
       163
       +
             }

     

       129
       164
        
       

     

       130
       130
       -
       const oldPreloadPath: string = ipcRenderer.sendSync(constants.ipcGetOldPreloadPath);

     

       131
       131
       -
       init(oldPreloadPath);

     

       165
       165
       +
             if (document.readyState === "complete") {

     

       166
       166
       +
               replayScripts();

     

       167
       167
       +
             } else {

     

       168
       168
       +
               window.addEventListener("load", replayScripts);

     

       169
       169
       +
             }

     

       170
       170
       +
           } catch (e) {

     

       171
       171
       +
             logger.error("Error restoring original scripts:", e);

     

       172
       172
       +
           }

     

       173
       173
       +
         })();

     

       174
       174
       +
       });

packages/types/src/constants.ts

···

       4
       4
        
       export const repoUrlFile = ".moonlight-repo-url";

     

       5
       5
        
       export const installedVersionFile = ".moonlight-installed-version";

     

       6
       6
        
       

     

       7
       7
       +
       export const ipcNodePreloadKickoff = "_moonlight_nodePreloadKickoff";

     

       7
       8
        
       export const ipcGetOldPreloadPath = "_moonlight_getOldPreloadPath";

     

       9
       9
       +
       

     

       8
       10
        
       export const ipcGetAppData = "_moonlight_getAppData";

     

       9
       11
        
       export const ipcGetIsMoonlightDesktop = "_moonlight_getIsMoonlightDesktop";

     

       10
       12
        
       export const ipcMessageBox = "_moonlight_messageBox";

+4 -10

packages/web-preload/src/index.ts

···

       49
       49
        
           logger.error("Error setting up web-preload", e);

     

       50
       50
        
         }

     

       51
       51
        
       

     

       52
       52
       -
         if (MOONLIGHT_ENV === "web-preload") {

     

       53
       53
       -
           window.addEventListener("DOMContentLoaded", () => {

     

       54
       54
       -
             installStyles();

     

       55
       55
       -
           });

     

       52
       52
       +
         if (document.readyState === "complete") {

     

       53
       53
       +
           installStyles();

     

       56
       54
        
         } else {

     

       57
       57
       -
           installStyles();

     

       55
       55
       +
           window.addEventListener("load", installStyles);

     

       58
       56
        
         }

     

       59
       57
        
       }

     

       60
       58
        
       

     

       61
       61
       -
       if (MOONLIGHT_ENV === "web-preload") {

     

       62
       62
       -
         load();

     

       63
       63
       -
       } else {

     

       64
       64
       -
         window._moonlightBrowserLoad = load;

     

       65
       65
       -
       }

     

       59
       59
       +
       window._moonlightBrowserLoad = load;