Report kernel status on startup (#197)

* Introducing labextension

* Report kernel status to main thread

* Logs dialog

* Remove log

* Using the logger panel

* Update mambajs

* Add back toolbar button

* WAT

* Fix closing -> reopening the logs

* Scroll to bottom automatically

* Linter

* Some button styling

* Animate button in case of kernel error

* Remove debug logs

* Linter

* Use toolbar factory

* Remove debug logs

* Review comment

* Move toolbar button as per comment review

* Recreate widget if disposed

Author: martinRenou

.gitignore

@@ -6,6 +6,7 @@ node_modules/
 *.egg-info/
 .ipynb_checkpoints
 *.tsbuildinfo
+jupyterlite_xeus/liteextension
 jupyterlite_xeus/labextension
 # Version file is handled by hatchling
 jupyterlite_xeus/_version.py

jupyterlite_xeus/__init__.py

@@ -11,4 +11,4 @@
 
 
 def _jupyter_labextension_paths():
-    return [{"src": "labextension", "dest": "@jupyterlite/xeus"}]
+    return [{"src": "labextension", "dest": "@jupyterlite/xeus"}, {"src": "liteextension", "dest": "@jupyterlite/xeus-kernels-extension"}]

packages/xeus-extension/package.json

@@ -14,10 +14,13 @@
     "license": "BSD-3-Clause",
     "author": "JupyterLite Contributors",
     "files": [
-        "lib/**/*.{d.ts,eot,gif,html,jpg,js,js.map,json,png,svg,woff2,ttf}"
+        "lib/**/*.{d.ts,eot,gif,html,jpg,js,js.map,json,png,svg,woff2,ttf}",
+        "style/**/*.{css,js,eot,gif,html,jpg,json,png,svg,woff2,ttf}",
+        "schema/*.json"
     ],
     "main": "lib/index.js",
     "types": "lib/index.d.ts",
+    "style": "style/index.css",
     "repository": {
         "type": "git",
         "url": "https://github.com/jupyterlite/xeus.git"
@@ -38,10 +41,10 @@
         "watch:labextension": "jupyter labextension watch ."
     },
     "dependencies": {
+        "@jupyterlab/application": "^4.3.4",
         "@jupyterlab/coreutils": "^6",
-        "@jupyterlite/contents": "^0.2.0 || ^0.3.0 || ^0.4.5 || ^0.5.1",
-        "@jupyterlite/kernel": "^0.2.0 || ^0.3.0 || ^0.4.5 || ^0.5.1",
-        "@jupyterlite/server": "^0.2.0 || ^0.3.0 || ^0.4.5 || ^0.5.1",
+        "@jupyterlab/logconsole": "^4.3.5",
+        "@jupyterlab/notebook": "^4.3.5",
         "@jupyterlite/xeus": "^4.0.0-a0",
         "@lumino/coreutils": "^2"
     },
@@ -63,26 +66,14 @@
     "publishConfig": {
         "access": "public"
     },
+    "sideEffects": [
+        "style/*.css",
+        "style/index.js"
+    ],
+    "styleModule": "style/index.js",
     "jupyterlab": {
         "extension": true,
-        "outputDir": "../../jupyterlite_xeus/labextension",
-        "webpackConfig": "lab.webpack.config.js",
-        "sharedPackages": {
-            "@jupyterlite/kernel": {
-                "bundled": false,
-                "singleton": true
-            },
-            "@jupyterlite/server": {
-                "bundled": false,
-                "singleton": true
-            },
-            "@jupyterlite/contents": {
-                "bundled": false,
-                "singleton": true
-            }
-        }
-    },
-    "jupyterlite": {
-        "liteExtension": true
+        "schemaDir": "schema",
+        "outputDir": "../../jupyterlite_xeus/labextension"
     }
 }

packages/xeus-extension/schema/xeus-kernel-status.json

@@ -0,0 +1,10 @@
+{
+  "title": "Xeus Kernels Settings",
+  "description": "Xeus Kernels Settings.",
+  "jupyter.lab.toolbars": {
+    "Notebook": [{ "name": "xeusKernelLogs", "rank": 1002.5 }]
+  },
+  "properties": {},
+  "additionalProperties": false,
+  "type": "object"
+}

packages/xeus-extension/src/index.ts

@@ -2,133 +2,192 @@
 // Copyright (c) JupyterLite Contributors
 // Distributed under the terms of the Modified BSD License.
 
-import { PageConfig, URLExt } from '@jupyterlab/coreutils';
 import {
-  IServiceWorkerManager,
-  JupyterLiteServer,
-  JupyterLiteServerPlugin
-} from '@jupyterlite/server';
-import { IBroadcastChannelWrapper } from '@jupyterlite/contents';
-import { IKernel, IKernelSpecs } from '@jupyterlite/kernel';
-
-import { WebWorkerKernel } from '@jupyterlite/xeus';
-import { IEmpackEnvMetaFile } from './tokens';
-
-/**
- * Fetches JSON data from the specified URL asynchronously.
- *
- * This function constructs the full URL using the base URL from the PageConfig and
- * the provided relative URL. It then performs a GET request using the Fetch API
- * and returns the parsed JSON data.
- *
- * @param {string} url - The relative URL to fetch the JSON data from.
- * @returns {Promise<any>} - A promise that resolves to the parsed JSON data.
- * @throws {Error} - Throws an error if the HTTP request fails.
- *
- */
-async function getJson(url: string) {
-  const jsonUrl = URLExt.join(PageConfig.getBaseUrl(), url);
-  const response = await fetch(jsonUrl, { method: 'GET' });
-
-  if (!response.ok) {
-    throw new Error(`HTTP error! status: ${response.status}`);
-  }
+  JupyterFrontEndPlugin,
+  JupyterFrontEnd
+} from '@jupyterlab/application';
+
+import {
+  MainAreaWidget,
+  IToolbarWidgetRegistry,
+  showErrorMessage
+} from '@jupyterlab/apputils';
+
+import { listIcon, ToolbarButton } from '@jupyterlab/ui-components';
+
+import { IRenderMimeRegistry } from '@jupyterlab/rendermime';
+
+import { LoggerRegistry, LogConsolePanel } from '@jupyterlab/logconsole';
+
+import { NotebookPanel } from '@jupyterlab/notebook';
 
-  const data = await response.json();
-  return data;
+enum KernelStatus {
+  None = 0,
+  Info = 1,
+  Warning = 2,
+  Error = 3
 }
 
-const kernelPlugin: JupyterLiteServerPlugin<void> = {
-  id: '@jupyterlite/xeus-kernel:register',
+const kernelStatusPlugin: JupyterFrontEndPlugin<void> = {
+  id: '@jupyterlite/xeus-extension:xeus-kernel-status',
   autoStart: true,
-  requires: [IKernelSpecs],
-  optional: [
-    IServiceWorkerManager,
-    IBroadcastChannelWrapper,
-    IEmpackEnvMetaFile
-  ],
+  requires: [IToolbarWidgetRegistry, IRenderMimeRegistry],
   activate: async (
-    app: JupyterLiteServer,
-    kernelspecs: IKernelSpecs,
-    serviceWorker?: IServiceWorkerManager,
-    broadcastChannel?: IBroadcastChannelWrapper,
-    empackEnvMetaFile?: IEmpackEnvMetaFile
+    app: JupyterFrontEnd,
+    toolbarRegistry: IToolbarWidgetRegistry,
+    rendermime: IRenderMimeRegistry
   ) => {
-    // Fetch kernel list
-    let kernelList: string[] = [];
-    try {
-      kernelList = await getJson('xeus/kernels.json');
-    } catch (err) {
-      console.log(`Could not fetch xeus/kernels.json: ${err}`);
-      throw err;
-    }
-    const contentsManager = app.serviceManager.contents;
+    const toolbarFactory = (panel: NotebookPanel) => {
+      const session = panel.sessionContext;
 
-    for (const kernel of kernelList) {
-      // Fetch kernel spec
-      const kernelspec = await getJson(
-        'xeus/kernels/' + kernel + '/kernel.json'
-      );
-      kernelspec.name = kernel;
-      kernelspec.dir = kernel;
-      for (const [key, value] of Object.entries(kernelspec.resources)) {
-        kernelspec.resources[key] = URLExt.join(
-          PageConfig.getBaseUrl(),
-          value as string
-        );
-      }
-      kernelspecs.register({
-        spec: kernelspec,
-        create: async (options: IKernel.IOptions): Promise<IKernel> => {
-          const mountDrive = !!(
-            (serviceWorker?.enabled && broadcastChannel?.enabled) ||
-            crossOriginIsolated
-          );
-
-          if (mountDrive) {
-            console.info(
-              `${kernelspec.name} contents will be synced with Jupyter Contents`
-            );
-          } else {
-            console.warn(
-              `${kernelspec.name} contents will NOT be synced with Jupyter Contents`
+      let currentState = KernelStatus.None;
+      let kernelId: string | undefined;
+      let kernelName: string | undefined;
+      let logConsolePanel: LogConsolePanel | undefined;
+      let sourceId: string | undefined;
+      let logConsoleWidget: MainAreaWidget<LogConsolePanel> | undefined;
+
+      const createWidget = () => {
+        if (!logConsolePanel) {
+          return;
+        }
+
+        logConsoleWidget = new MainAreaWidget<LogConsolePanel>({
+          content: logConsolePanel
+        });
+        logConsoleWidget.title.label = 'Kernel Logs';
+        logConsoleWidget.title.icon = listIcon;
+        logConsoleWidget.id = `${sourceId}-widget`;
+      };
+
+      const toolbarButton = new ToolbarButton({
+        icon: listIcon,
+        onClick: () => {
+          if (!logConsolePanel) {
+            showErrorMessage(
+              'Cannot show logs',
+              'Cannot show logs for the current kernel'
             );
+            return;
           }
-          const link = empackEnvMetaFile
-            ? await empackEnvMetaFile.getLink(kernelspec)
-            : '';
-
-          return new WebWorkerKernel({
-            ...options,
-            contentsManager,
-            mountDrive,
-            kernelSpec: kernelspec,
-            empackEnvMetaLink: link
-          });
-        }
+
+          if (!logConsoleWidget) {
+            createWidget();
+          }
+
+          if (logConsoleWidget) {
+            if (logConsoleWidget.isDisposed) {
+              createWidget();
+            }
+
+            if (!logConsoleWidget.isAttached) {
+              app.shell.add(logConsoleWidget, 'main', { mode: 'split-bottom' });
+            }
+
+            app.shell.activateById(logConsoleWidget.id);
+          }
+        },
+        tooltip: 'Show kernel logs'
       });
-    }
-    await app.serviceManager.kernelspecs.refreshSpecs();
-  }
-};
 
-const empackEnvMetaPlugin: JupyterLiteServerPlugin<IEmpackEnvMetaFile> = {
-  id: '@jupyterlite/xeus:empack-env-meta',
-  autoStart: true,
-  provides: IEmpackEnvMetaFile,
-  activate: (): IEmpackEnvMetaFile => {
-    return {
-      getLink: async (kernelspec: Record<string, any>) => {
-        const kernelName = kernelspec.name;
-        const kernel_root_url = URLExt.join(
-          PageConfig.getBaseUrl(),
-          `xeus/kernels/${kernelName}`
+      session.kernelChanged.connect(() => {
+        kernelId = session.session?.id;
+        kernelName = session.session?.kernel?.name;
+
+        currentState = KernelStatus.None;
+
+        if (!kernelId || !kernelName) {
+          return;
+        }
+
+        sourceId = `${kernelName}-${kernelId}`;
+
+        logConsolePanel = new LogConsolePanel(
+          new LoggerRegistry({
+            defaultRendermime: rendermime,
+            maxLength: 1000
+          })
         );
-        return `${kernel_root_url}`;
-      }
+
+        logConsolePanel.source = sourceId;
+
+        const channel = new BroadcastChannel(`/kernel-broadcast/${kernelId}`);
+
+        if (logConsolePanel.logger) {
+          logConsolePanel.logger.level = 'info';
+        }
+
+        // Scroll to bottom when new content shows up
+        logConsolePanel.logger?.contentChanged.connect(() => {
+          const element = document.getElementById(`source:${sourceId}`);
+
+          if (!element) {
+            return;
+          }
+
+          const lastChild = element.lastElementChild;
+          if (lastChild) {
+            lastChild.scrollIntoView({ behavior: 'smooth' });
+          }
+        });
+
+        channel.onmessage = event => {
+          if (!logConsolePanel) {
+            return;
+          }
+
+          switch (event.data.type) {
+            case 'log':
+              logConsolePanel.logger?.log({
+                type: 'text',
+                level: 'info',
+                data: event.data.msg
+              });
+
+              if (currentState < KernelStatus.Info) {
+                currentState = KernelStatus.Info;
+                toolbarButton.addClass('xeus-kernel-status-info');
+              }
+              break;
+            case 'warn':
+              logConsolePanel.logger?.log({
+                type: 'text',
+                level: 'warning',
+                data: event.data.msg
+              });
+
+              if (currentState < KernelStatus.Warning) {
+                currentState = KernelStatus.Warning;
+                toolbarButton.addClass('xeus-kernel-status-warning');
+              }
+              break;
+            case 'error':
+              logConsolePanel.logger?.log({
+                type: 'text',
+                level: 'error',
+                data: event.data.msg
+              });
+
+              if (currentState < KernelStatus.Error) {
+                currentState = KernelStatus.Error;
+                toolbarButton.addClass('xeus-kernel-status-error');
+              }
+              break;
+          }
+        };
+      });
+
+      return toolbarButton;
     };
+
+    if (toolbarRegistry) {
+      toolbarRegistry.addFactory<NotebookPanel>(
+        'Notebook',
+        'xeusKernelLogs',
+        toolbarFactory
+      );
+    }
   }
 };
 
-export default [empackEnvMetaPlugin, kernelPlugin];
-export { IEmpackEnvMetaFile };
+export default [kernelStatusPlugin];