Passing the link of empack_env_meta.json file

src/index.ts

@@ -12,6 +12,7 @@ import { IBroadcastChannelWrapper } from '@jupyterlite/contents';
 import { IKernel, IKernelSpecs } from '@jupyterlite/kernel';
 
 import { WebWorkerKernel } from './web_worker_kernel';
+import { IEmpackEnvMetaFile } from './tokens';
 
 function getJson(url: string) {
   const json_url = URLExt.join(PageConfig.getBaseUrl(), url);
@@ -29,17 +30,18 @@ try {
   throw err;
 }
 
-const plugins = kernel_list.map((kernel): JupyterLiteServerPlugin<void> => {
+const plugins = kernel_list.map((kernel): JupyterLiteServerPlugin<void| IEmpackEnvMetaFile> => {
   return {
     id: `@jupyterlite/xeus-${kernel}:register`,
     autoStart: true,
     requires: [IKernelSpecs],
-    optional: [IServiceWorkerManager, IBroadcastChannelWrapper],
+    optional: [IServiceWorkerManager, IBroadcastChannelWrapper, IEmpackEnvMetaFile],
     activate: (
       app: JupyterLiteServer,
       kernelspecs: IKernelSpecs,
       serviceWorker?: IServiceWorkerManager,
-      broadcastChannel?: IBroadcastChannelWrapper
+      broadcastChannel?: IBroadcastChannelWrapper,
+      empackEnvMetaFile?: IEmpackEnvMetaFile
     ) => {
       // Fetch kernel spec
       const kernelspec = getJson('xeus/kernels/' + kernel + '/kernel.json');
@@ -53,7 +55,6 @@ const plugins = kernel_list.map((kernel): JupyterLiteServerPlugin<void> => {
       }
 
       const contentsManager = app.serviceManager.contents;
-
       kernelspecs.register({
         spec: kernelspec,
         create: async (options: IKernel.IOptions): Promise<IKernel> => {
@@ -71,17 +72,38 @@ const plugins = kernel_list.map((kernel): JupyterLiteServerPlugin<void> => {
               `${kernelspec.name} contents will NOT be synced with Jupyter Contents`
             );
           }
+          const link = empackEnvMetaFile ? await empackEnvMetaFile.getLink(kernelspec.dir): '';
 
           return new WebWorkerKernel({
             ...options,
             contentsManager,
             mountDrive,
-            kernelSpec: kernelspec
+            kernelSpec: kernelspec,
+            empackEnvMetaLink: link
           });
         }
       });
     }
   };
 });
 
+const empackEnvMetaPlugin: JupyterLiteServerPlugin<IEmpackEnvMetaFile> = {
+  id: `@jupyterlite/xeus-python:empack-env-meta`,
+  autoStart: true,
+  provides: IEmpackEnvMetaFile,
+  activate: (): IEmpackEnvMetaFile => {
+    return {
+      getLink: async (kernel?: string) => {
+         const kernel_root_url = URLExt.join(
+            PageConfig.getBaseUrl(),
+            `xeus/kernels/${kernel}`
+          );
+          return `${kernel_root_url}`;
+      }
+    };
+  },
+};
+
+plugins.push(empackEnvMetaPlugin);
+
 export default plugins;

src/tokens.ts

@@ -12,6 +12,7 @@ import {
 } from '@jupyterlite/contents';
 
 import { IWorkerKernel } from '@jupyterlite/kernel';
+import { Token } from '@lumino/coreutils';
 
 /**
  * An interface for Xeus workers.
@@ -85,5 +86,15 @@ export namespace IXeusWorkerKernel {
     baseUrl: string;
     kernelSpec: any;
     mountDrive: boolean;
+    empackEnvMetaLink?: string;
   }
 }
+
+export interface IEmpackEnvMetaFile {
+  /**
+   * Get empack_env_meta link.
+   */
+  getLink: (kernel?: string) => Promise<string>;
+}
+
+export const IEmpackEnvMetaFile = new Token<IEmpackEnvMetaFile>('@jupyterlite/xeus-python:IEmpackEnvMetaFile');

src/web_worker_kernel.ts

@@ -29,17 +29,17 @@ export class WebWorkerKernel implements IKernel {
    * @param options The instantiation options for a new WebWorkerKernel
    */
   constructor(options: WebWorkerKernel.IOptions) {
-    const { id, name, sendMessage, location, kernelSpec, contentsManager } =
+    const { id, name, sendMessage, location, kernelSpec, contentsManager, empackEnvMetaLink } =
       options;
     this._id = id;
     this._name = name;
     this._location = location;
     this._kernelSpec = kernelSpec;
     this._contentsManager = contentsManager;
     this._sendMessage = sendMessage;
+    this._empackEnvMetaLink = empackEnvMetaLink;
     this._worker = this.initWorker(options);
     this._remoteKernel = this.initRemote(options);
-
     this.initFileSystem(options);
   }
 
@@ -99,11 +99,13 @@ export class WebWorkerKernel implements IKernel {
       };
       remote = wrap(this._worker) as Remote<IXeusWorkerKernel>;
     }
+
     remote
       .initialize({
         kernelSpec: this._kernelSpec,
         baseUrl: PageConfig.getBaseUrl(),
-        mountDrive: options.mountDrive
+        mountDrive: options.mountDrive,
+        empackEnvMetaLink: this._empackEnvMetaLink,
       })
       .then(this._ready.resolve.bind(this._ready));
 
@@ -290,6 +292,7 @@ export class WebWorkerKernel implements IKernel {
     | undefined = undefined;
   private _parent: KernelMessage.IMessage | undefined = undefined;
   private _ready = new PromiseDelegate<void>();
+  private _empackEnvMetaLink: string | undefined;
 }
 
 /**
@@ -303,5 +306,6 @@ export namespace WebWorkerKernel {
     contentsManager: Contents.IManager;
     mountDrive: boolean;
     kernelSpec: any;
+    empackEnvMetaLink?: string | undefined;
   }
 }

src/worker.ts

@@ -103,7 +103,7 @@ export class XeusRemoteKernel {
   }
 
   async initialize(options: IXeusWorkerKernel.IOptions): Promise<void> {
-    const { baseUrl, kernelSpec } = options;
+    const { baseUrl, kernelSpec, empackEnvMetaLink } = options;
     // location of the kernel binary on the server
     const binary_js = URLExt.join(baseUrl, kernelSpec.argv[0]);
     const binary_wasm = binary_js.replace('.js', '.wasm');
@@ -125,7 +125,7 @@ export class XeusRemoteKernel {
       // This function is usually implemented in the pre/post.js
       // in the emscripten build of that kernel
       if (globalThis.Module['async_init'] !== undefined) {
-        const kernel_root_url = URLExt.join(
+        const kernel_root_url = empackEnvMetaLink ? empackEnvMetaLink : URLExt.join(
           baseUrl,
           `xeus/kernels/${kernelSpec.dir}`
         );