@fails-components/jupyter-launcher 0.0.1-alpha.10

package/lib/index.js

@@ -0,0 +1,631 @@
+import { ILabStatus } from '@jupyterlab/application';
+import { IDocumentManager } from '@jupyterlab/docmanager';
+import { ServerConnection } from '@jupyterlab/services';
+import { PageConfig, URLExt } from '@jupyterlab/coreutils';
+import { INotebookShell } from '@jupyter-notebook/application';
+import { NotebookActions } from '@jupyterlab/notebook';
+import { Token } from '@lumino/coreutils';
+import { Signal } from '@lumino/signaling';
+export const IFailsLauncherInfo = new Token('@fails-components/jupyter-fails:IFailsLauncherInfo', 'A service to communicate with FAILS.');
+let screenShotPatchInstalled = false;
+const installScreenShotPatches = () => {
+    if (screenShotPatchInstalled) {
+        return;
+    }
+    // Monkey patch the HTMLCanvasObject
+    const oldGetContext = HTMLCanvasElement.prototype.getContext;
+    // @ts-expect-error type do not matter
+    HTMLCanvasElement.prototype.getContext = function (contexttype, contextAttributes) {
+        if (contexttype === 'webgl' || contexttype === 'webgl2') {
+            const newcontext = { ...contextAttributes };
+            newcontext.preserveDrawingBuffer = true;
+            return oldGetContext.apply(this, [contexttype, newcontext]);
+        }
+        return oldGetContext.apply(this, [contexttype, contextAttributes]);
+    };
+    screenShotPatchInstalled = true;
+};
+// Monkey patch fetch, e.g. for GDPR compliance
+let fetchPatchInstalled = false;
+const installFetchPatches = ({ allowedSites = undefined, proxySites = undefined, proxyURL }) => {
+    if (fetchPatchInstalled) {
+        return;
+    }
+    const allowedOrigins = [location.origin, ...(allowedSites || [])];
+    const allowedOriginsString = allowedOrigins
+        .map(el => "'" + new URL(el).origin + "'")
+        .join(',');
+    const proxySitesString = (proxySites || [])
+        .map(el => "'" + new URL(el).origin + "'")
+        .join(',');
+    // Monkey patch fetch
+    const oldFetch = globalThis.fetch;
+    globalThis.fetch = async (url, options = {}) => {
+        const urlObj = url instanceof URL
+            ? url
+            : new URL(url instanceof Request ? url.url : url, location.href);
+        if (allowedOrigins.includes(urlObj.origin)) {
+            return oldFetch(url instanceof Request ? url : urlObj, options);
+        }
+        if (proxySites && proxySites.includes(urlObj.origin)) {
+            // rewrite the URL and response
+            const resURL = proxyURL + urlObj.hostname + urlObj.pathname;
+            if (url instanceof Request) {
+                const request = url;
+                const newRequest = new Request(resURL, {
+                    method: request.method,
+                    headers: request.headers,
+                    body: request.body,
+                    credentials: request.credentials,
+                    mode: request.mode,
+                    integrity: request.integrity,
+                    keepalive: request.keepalive,
+                    referrerPolicy: request.referrerPolicy,
+                    cache: request.cache,
+                    redirect: request.redirect,
+                    referrer: request.referrer,
+                    signal: request.signal
+                });
+                return oldFetch(newRequest, options);
+            }
+            else {
+                urlObj.href = resURL;
+                return oldFetch(urlObj, options);
+            }
+        }
+        console.log('alien fetch URL:', urlObj.href);
+        return new Response('Blocked domain, access forbidden', {
+            status: 403,
+            statusText: 'Forbidden',
+            headers: { 'Content-Type': 'text/plain' }
+        });
+    };
+    const oldImportScripts = globalThis.importScripts;
+    globalThis.importScripts = (...args) => {
+        const newargs = args.map(url => {
+            const urlObj = new URL(url, location.href);
+            if (allowedOrigins.includes(urlObj.origin)) {
+                return url;
+            }
+            if (proxySites && proxySites.includes(urlObj.origin)) {
+                return proxyURL + urlObj.hostname + urlObj.pathname;
+            }
+            throw new Error('Script is from blocked URL');
+        });
+        return oldImportScripts(...newargs);
+    };
+    const oldWorker = Worker;
+    const NewWorker = function (script, options) {
+        const scriptURL = script instanceof URL ? script : new URL(script, location.href);
+        if (!allowedOrigins.includes(scriptURL.origin)) {
+            console.log('Creating worker from blocked origin:', scriptURL.origin);
+            return;
+        }
+        console.log('Tap into creating worker:', scriptURL.href);
+        const injectPrefix = `(function() {
+      const allowedOrigins = [ ${allowedOriginsString} ];
+      const proxySites = [ ${proxySitesString} ];
+      const proxyURL = '${proxyURL}';
+      const oldFetch = globalThis.fetch;
+      globalThis.fetch = async function(url, options = {}) {
+        const urlObj = url instanceof URL ? url : new URL(url instanceof Request ? url.url : url, location.href);
+        if (allowedOrigins.includes(urlObj.origin)) {
+          return oldFetch(url instanceof Request ? url : urlObj, options);
+        }
+        if (proxySites && proxySites.includes(urlObj.origin)) {
+           // rewrite the URL and response
+          const resURL = proxyURL + urlObj.hostname + urlObj.pathname;
+          console.log('proxy url debug', resURL, urlObj.href);
+          if (url instanceof Request) {
+            const request = url;
+            const newRequest = new Request(resURL, {
+              method: request.method,
+              headers: request.headers,
+              body: request.body,
+              credentials: request.credentials,
+              mode: request.mode,
+              integrity: request.integrity,
+              keepalive: request.keepalive,
+              referrerPolicy: request.referrerPolicy,
+              cache: request.cache,
+              redirect: request.redirect,
+              referrer: request.referrer,
+              signal: request.signal
+          });
+          console.log('proxy request debug', newRequest, request);
+          return oldFetch(newRequest, options);
+        } else {
+          urlObj.href = resURL;
+          return oldFetch(urlObj, options);
+        }
+      }
+      console.log('alien fetch URL worker:', urlObj.href);
+      return new Response('Blocked domain, access forbidden',{
+        status: 403,
+        statusText: 'Forbidden',
+        headers: { 'Content-Type': 'text/plain' }
+      });
+      };
+      const oldImportScripts = globalThis.importScripts;
+      globalThis.importScripts = (...args) => {
+      const newargs = args.map(url => {
+        const urlObj = new URL(url, location.href);
+        if (allowedOrigins.includes(urlObj.origin)) {
+          return url;
+        }
+        if (proxySites && proxySites.includes(urlObj.origin)) {
+          return proxyURL + urlObj.hostname + urlObj.pathname;
+        }
+          throw new Error('Script is from blocked URL');
+        });
+        return oldImportScripts(...newargs);
+      };
+      Object.defineProperty(globalThis, 'location', {
+        value: new URL('${scriptURL.href}'),
+        writable: false,
+        configurable: false,
+        enumerable: true,
+      });
+      })();`;
+        const inject = injectPrefix +
+            ((options === null || options === void 0 ? void 0 : options.type) === 'module'
+                ? `
+      import('${scriptURL.href}').catch(error => {
+        console.error('Can not load module patching Worker:', error);
+      });`
+                : `
+      importScripts('${scriptURL.href}')
+      `);
+        const blob = new Blob([inject], { type: 'application/javascript' });
+        const url = URL.createObjectURL(blob);
+        const newWorker = new oldWorker(url, options);
+        newWorker.addEventListener('message', () => {
+            URL.revokeObjectURL(url);
+        }, { once: true });
+        return newWorker;
+    };
+    NewWorker.prototype = oldWorker.prototype;
+    NewWorker.prototype.constructor = NewWorker;
+    globalThis.Worker = NewWorker;
+    fetchPatchInstalled = true;
+};
+class FailsLauncherInfo {
+    constructor(options) {
+        var _a, _b;
+        this._inLectureChanged = new Signal(this);
+        this._selectedAppidChanged = new Signal(this);
+        this._remoteUpdateMessageArrived = new Signal(this);
+        this._appletSizes = {};
+        this._appletSizesChanged = new Signal(this);
+        this._appletSizesProxy = new Proxy(this._appletSizes, {
+            get: (target, property) => {
+                if (typeof property !== 'symbol') {
+                    return target[property];
+                }
+            },
+            set: (target, property, value) => {
+                if (typeof property !== 'symbol') {
+                    if (target[property] !== value) {
+                        target[property] = value;
+                        this._appletSizesChanged.emit(target);
+                    }
+                    return true;
+                }
+                return false;
+            }
+        });
+        this._inLecture = (_a = options === null || options === void 0 ? void 0 : options.inLecture) !== null && _a !== void 0 ? _a : false;
+        this._selectedAppid = (_b = options === null || options === void 0 ? void 0 : options.selectedAppid) !== null && _b !== void 0 ? _b : undefined;
+    }
+    get inLectureChanged() {
+        return this._inLectureChanged;
+    }
+    get inLecture() {
+        return this._inLecture;
+    }
+    set inLecture(value) {
+        if (value === this._inLecture) {
+            return;
+        }
+        this._inLecture = value;
+        if (value === false && this._selectedAppid) {
+            this._selectedAppid = undefined;
+            this._selectedAppidChanged.emit(undefined);
+        }
+        this._inLectureChanged.emit(value);
+    }
+    get selectedAppid() {
+        return this._selectedAppid;
+    }
+    get selectedAppidChanged() {
+        return this._selectedAppidChanged;
+    }
+    set selectedAppid(appid) {
+        if (appid === this._selectedAppid) {
+            return;
+        }
+        this._selectedAppid = appid;
+        if (!this._inLecture && typeof appid !== 'undefined') {
+            this._inLecture = true;
+            this._inLectureChanged.emit(true);
+        }
+        else if (this._inLecture && typeof appid === 'undefined') {
+            this._inLecture = false;
+            this._inLectureChanged.emit(false);
+        }
+        this._selectedAppidChanged.emit(appid);
+    }
+    get appletSizes() {
+        return this._appletSizesProxy;
+    }
+    get appletSizesChanged() {
+        return this._appletSizesChanged;
+    }
+    get updateMessageArrived() {
+        return this._updateMessageArrived;
+    }
+    set updateMessageArrived(updateMessageArrived) {
+        this._updateMessageArrived = updateMessageArrived;
+    }
+    get remoteUpdateMessageArrived() {
+        return this._remoteUpdateMessageArrived;
+    }
+    receiveRemoteUpdateMessage(message) {
+        this._remoteUpdateMessageArrived.emit(message);
+    }
+}
+function activateFailsLauncher(app, docManager, status, shell) {
+    // parts taken from repl-extension
+    const { /* commands, */ serviceManager, started } = app;
+    Promise.all([started, serviceManager.ready]).then(async () => {
+        /*  commands.execute('notebook:create-new', {
+            kernelId: undefined,
+            kernelName: undefined
+          }); */
+        // TODO select kernel and replace with content
+    });
+    // TODO steer with messages
+    const { docRegistry } = app;
+    const failsLauncherInfo = new FailsLauncherInfo();
+    let currentDocWidget;
+    const serverSettings = app.serviceManager.serverSettings;
+    const licensesUrl = URLExt.join(PageConfig.getBaseUrl(), PageConfig.getOption('licensesUrl')) +
+        '/';
+    // Install Messagehandler
+    if (!window.failsCallbacks) {
+        window.failsCallbacks = {};
+    }
+    let senderOrigin;
+    const _failsCallbacks = window.failsCallbacks;
+    _failsCallbacks.postMessageToFails = (message, transfer) => {
+        if (typeof senderOrigin !== 'undefined') {
+            window.parent.postMessage(message, senderOrigin, transfer);
+        }
+    };
+    status.dirtySignal.connect((sender, dirty) => {
+        _failsCallbacks.postMessageToFails({
+            task: 'docDirty',
+            dirty
+        });
+    });
+    failsLauncherInfo.reportMetadata = metadata => {
+        _failsCallbacks.postMessageToFails({
+            task: 'reportMetadata',
+            metadata
+        });
+    };
+    failsLauncherInfo.inLectureChanged.connect((sender, inLecture) => {
+        if (shell !== null) {
+            shell.menu.setHidden(inLecture);
+        }
+    });
+    failsLauncherInfo.appletSizesChanged.connect((sender, appletSizes) => {
+        _failsCallbacks.postMessageToFails({
+            task: 'reportFailsAppletSizes',
+            appletSizes
+        });
+    });
+    let interceptorActivated = false;
+    const sendInterceptorUpdate = (sender, message) => {
+        _failsCallbacks.postMessageToFails({
+            task: 'sendInterceptorUpdate',
+            ...message
+        });
+    };
+    window.addEventListener('message', (event) => {
+        var _a;
+        // TODO identify the embedding page.
+        if (typeof senderOrigin === 'undefined') {
+            senderOrigin = event.origin;
+        }
+        // handle FAILS control messages
+        switch (event.data.type) {
+            case 'loadJupyter':
+                {
+                    const loadJupyterInfo = event.data;
+                    failsLauncherInfo.inLecture =
+                        (_a = loadJupyterInfo.inLecture) !== null && _a !== void 0 ? _a : failsLauncherInfo.inLecture;
+                    docManager.autosave = false; // do not autosave
+                    if (loadJupyterInfo.installScreenShotPatches) {
+                        installScreenShotPatches();
+                    }
+                    if (loadJupyterInfo.installGDPRProxy) {
+                        installFetchPatches(loadJupyterInfo.installGDPRProxy);
+                    }
+                    // TODO send fileData to contents together with filename, and wait for fullfillment
+                    // may be use a promise for fullfillment, e.g. pass a resolve
+                    // afterwards we load the file or new file into to the contexts
+                    // we may also send license information
+                    _failsCallbacks.callContents({
+                        task: 'loadFile',
+                        fileData: loadJupyterInfo.fileData,
+                        fileName: loadJupyterInfo.fileName
+                    })
+                        .then(() => {
+                        // ok the file is placed inside the file system now load it into the app
+                        const kernel = {
+                            name: loadJupyterInfo.kernelName || 'python' // 'xpython' for xeus
+                        };
+                        const defaultFactory = docRegistry.defaultWidgetFactory(loadJupyterInfo.fileName).name;
+                        const factory = defaultFactory;
+                        currentDocWidget = docManager.open(loadJupyterInfo.fileName, factory, kernel, {
+                            ref: '_noref'
+                        });
+                        if (loadJupyterInfo.appid) {
+                            failsLauncherInfo.selectedAppid = loadJupyterInfo.appid;
+                        }
+                        let rerunAfterKernelStart = loadJupyterInfo.rerunAtStartup;
+                        if (typeof currentDocWidget !== 'undefined') {
+                            const notebookPanel = currentDocWidget;
+                            notebookPanel.sessionContext.statusChanged.connect((context, status) => {
+                                _failsCallbacks.postMessageToFails({
+                                    task: 'reportKernelStatus',
+                                    status
+                                });
+                                if (status === 'idle' && rerunAfterKernelStart) {
+                                    console.log('Run all cells after startup');
+                                    const { context, content } = notebookPanel;
+                                    const cells = content.widgets;
+                                    NotebookActions.runCells(content, cells, context.sessionContext)
+                                        .then(() => {
+                                        console.log('Run all cells after startup finished');
+                                    })
+                                        .catch(error => {
+                                        console.log('Run all cells after startup error', error);
+                                    });
+                                    rerunAfterKernelStart = false;
+                                }
+                            });
+                        }
+                    })
+                        .catch(error => {
+                        console.log('Problem task load file', error);
+                    });
+                }
+                break;
+            case 'saveJupyter':
+                {
+                    const saveJupyter = event.data;
+                    if (typeof currentDocWidget === 'undefined') {
+                        _failsCallbacks.postMessageToFails({
+                            requestId: event.data.requestId,
+                            task: 'saveJupyter',
+                            error: 'No document loaded'
+                        });
+                        break;
+                    }
+                    const context = docManager.contextForWidget(currentDocWidget);
+                    if (typeof context === 'undefined') {
+                        _failsCallbacks.postMessageToFails({
+                            requestId: event.data.requestId,
+                            task: 'saveJupyter',
+                            error: 'No document context'
+                        });
+                        break;
+                    }
+                    context
+                        .save()
+                        .then(() => {
+                        // ok it was save to our virtual disk
+                        return _failsCallbacks.callContents({
+                            task: 'savedFile',
+                            fileName: saveJupyter.fileName
+                        });
+                    })
+                        .then(({ fileData }) => {
+                        _failsCallbacks.postMessageToFails({
+                            requestId: event.data.requestId,
+                            task: 'saveJupyter',
+                            fileData
+                        });
+                    })
+                        .catch((error) => {
+                        _failsCallbacks.postMessageToFails({
+                            requestId: event.data.requestId,
+                            task: 'saveJupyter',
+                            error: error.toString()
+                        });
+                    });
+                }
+                break;
+            case 'activateApp':
+                {
+                    const activateApp = event.data;
+                    if (activateApp.inLecture) {
+                        failsLauncherInfo.selectedAppid = activateApp.appid;
+                    }
+                    else {
+                        failsLauncherInfo.inLecture = false;
+                    }
+                    _failsCallbacks.postMessageToFails({
+                        requestId: event.data.requestId,
+                        task: 'activateApp'
+                    });
+                }
+                break;
+            case 'screenshotApp':
+                {
+                    const screenshotApp = event.data;
+                    const notebookPanel = currentDocWidget;
+                    if (!(typeof notebookPanel['takeAppScreenshot'] === 'function')) {
+                        _failsCallbacks.postMessageToFails({
+                            requestId: event.data.requestId,
+                            task: 'screenshotApp',
+                            error: 'Take App Screenshot unsupported'
+                        });
+                    }
+                    const screenShotTaker = notebookPanel;
+                    screenShotTaker
+                        .takeAppScreenshot({ dpi: screenshotApp.dpi })
+                        .then(async (screenshot) => {
+                        var _a, _b;
+                        if (screenshot) {
+                            const data = await screenshot.arrayBuffer();
+                            (_a = _failsCallbacks.postMessageToFails) === null || _a === void 0 ? void 0 : _a.call(_failsCallbacks, {
+                                requestId: event.data.requestId,
+                                task: 'screenshotApp',
+                                screenshot: { data, type: screenshot.type }
+                            }, [data]); // TODO add transferable
+                        }
+                        else {
+                            (_b = _failsCallbacks.postMessageToFails) === null || _b === void 0 ? void 0 : _b.call(_failsCallbacks, {
+                                requestId: event.data.requestId,
+                                task: 'screenshotApp',
+                                error: 'Screenshot failed?'
+                            });
+                        }
+                    })
+                        .catch((error) => {
+                        console.log('Screenshot error', error);
+                        _failsCallbacks.postMessageToFails({
+                            requestId: event.data.requestId,
+                            task: 'screenshotApp',
+                            error: error.toString()
+                        });
+                    });
+                }
+                break;
+            case 'activateInterceptor':
+                {
+                    const activateInterceptor = event.data;
+                    if (interceptorActivated !== activateInterceptor.activate &&
+                        failsLauncherInfo.updateMessageArrived) {
+                        if (!interceptorActivated) {
+                            failsLauncherInfo.updateMessageArrived.connect(sendInterceptorUpdate);
+                            interceptorActivated = true;
+                        }
+                        else {
+                            failsLauncherInfo.updateMessageArrived.disconnect(sendInterceptorUpdate);
+                            interceptorActivated = false;
+                        }
+                    }
+                    _failsCallbacks.postMessageToFails({
+                        requestId: event.data.requestId,
+                        task: 'activateInterceptor'
+                    });
+                }
+                break;
+            case 'receiveInterceptorUpdate':
+                {
+                    const receiveInterceptorUpdate = event.data;
+                    const { path, mime, state } = receiveInterceptorUpdate;
+                    const launcherInfo = failsLauncherInfo;
+                    launcherInfo.receiveRemoteUpdateMessage({ path, mime, state });
+                    _failsCallbacks.postMessageToFails({
+                        requestId: event.data.requestId,
+                        task: 'receiveInterceptorUpdate'
+                    });
+                }
+                break;
+            case 'restartKernelAndRerunCells':
+                {
+                    if (typeof currentDocWidget === 'undefined') {
+                        _failsCallbacks.postMessageToFails({
+                            requestId: event.data.requestId,
+                            task: 'restartKernelAndRerunCell',
+                            error: 'No document loaded'
+                        });
+                        break;
+                    }
+                    const notebookPanel = currentDocWidget;
+                    const { context, content } = notebookPanel;
+                    const cells = content.widgets;
+                    console.log('rerun kernel hook');
+                    notebookPanel.sessionContext
+                        .restartKernel()
+                        .then(async () => {
+                        await NotebookActions.runCells(content, cells, context.sessionContext);
+                        _failsCallbacks.postMessageToFails({
+                            requestId: event.data.requestId,
+                            task: 'restartKernelAndRerunCell',
+                            success: true
+                        });
+                    })
+                        .catch((error) => {
+                        _failsCallbacks.postMessageToFails({
+                            requestId: event.data.requestId,
+                            task: 'restartKernelAndRerunCell',
+                            error: error.toString()
+                        });
+                    });
+                }
+                break;
+            case 'getLicenses':
+                {
+                    ServerConnection.makeRequest(licensesUrl, {}, serverSettings)
+                        .then(async (response) => {
+                        const json = await response.json();
+                        _failsCallbacks.postMessageToFails({
+                            requestId: event.data.requestId,
+                            task: 'getLicenses',
+                            licenses: json
+                        });
+                    })
+                        .catch(error => {
+                        _failsCallbacks.postMessageToFails({
+                            requestId: event.data.requestId,
+                            task: 'getLicenses',
+                            error: error.toString()
+                        });
+                    });
+                }
+                break;
+        }
+    });
+    app.started.then(async () => {
+        if (window.parent) {
+            window.parent.postMessage({
+                task: 'appLoaded'
+            }, '*' // this is relatively safe, as we only say we are ready
+            );
+        }
+        if (shell) {
+            // we have a notebook
+            shell.collapseTop();
+            if (failsLauncherInfo.inLecture) {
+                const menuWrapper = shell['_menuWrapper'];
+                menuWrapper.hide();
+                // const main = shell['_main'] as SplitViewNotebookPanel;
+                // main.toolbar.hide();
+            }
+        }
+    });
+    return failsLauncherInfo;
+}
+const failsLauncher = {
+    id: '@fails-components/jupyter-fails:launcher',
+    description: 'Configures the notebooks application over messages',
+    autoStart: true,
+    activate: activateFailsLauncher,
+    provides: IFailsLauncherInfo,
+    requires: [IDocumentManager, ILabStatus],
+    optional: [INotebookShell]
+};
+/**
+ * Initialization data for the @fails-components/jupyter-launcher extension.
+ */
+const plugins = [
+    // all JupyterFrontEndPlugins
+    failsLauncher
+];
+export default plugins;