Use browsingContextId for drive access

Author: ianthomas23

package.json

@@ -63,7 +63,7 @@
         "@jupyterlab/services": "^7.4.0",
         "@jupyterlab/terminal": "^4.4.0",
         "@jupyterlab/terminal-extension": "^4.4.0",
-        "@jupyterlite/cockle": "^0.0.18",
+        "@jupyterlite/cockle": "^0.0.19",
         "@jupyterlite/contents": "0.6.0-alpha.9",
         "@jupyterlite/server": "0.6.0-alpha.9",
         "@lumino/coreutils": "^2.2.0",

src/index.ts

@@ -6,6 +6,7 @@ import {
   JupyterFrontEndPlugin
 } from '@jupyterlab/application';
 import { ITerminalManager, Terminal } from '@jupyterlab/services';
+import { IServiceWorkerManager } from '@jupyterlite/server';
 
 import { LiteTerminalManager } from './manager';
 
@@ -16,12 +17,23 @@ const terminalManagerPlugin: JupyterFrontEndPlugin<Terminal.IManager> = {
   id: '@jupyterlite/terminal:plugin',
   description: 'A terminal for JupyterLite',
   autoStart: true,
+  optional: [IServiceWorkerManager],
   provides: ITerminalManager,
-  activate: async (app: JupyterFrontEnd): Promise<Terminal.IManager> => {
+  activate: async (
+    app: JupyterFrontEnd,
+    serviceWorkerManager?: IServiceWorkerManager,
+  ): Promise<Terminal.IManager> => {
     console.log(
       'JupyterLite extension @jupyterlite/terminal:plugin is activated!'
     );
-    return new LiteTerminalManager();
+
+    console.log("DEBUG app:", app);
+    console.log("DEBUG IServiceWorkerManager:", serviceWorkerManager);
+
+    const browsingContextId = serviceWorkerManager?.browsingContextId;
+    console.log("DEBUG browsingContextId:", browsingContextId);
+
+    return new LiteTerminalManager({ browsingContextId });
   }
 };
 

src/manager.ts

@@ -12,8 +12,9 @@ export class LiteTerminalManager
   /**
    * Construct a new terminal manager.
    */
-  constructor(options: TerminalManager.IOptions = {}) {
+  constructor(options: LiteTerminalManager.IOptions) {
     super(options);
+    this.browsingContextId = options.browsingContextId;
 
     // Initialize internal data.
     this._ready = (async () => {
@@ -44,9 +45,9 @@ export class LiteTerminalManager
     const { model } = options;
     const { name } = model;
     console.log('==> LiteTerminalManager.connectTo', name);
-    const { serverSettings } = this;
-
-    const terminal = new LiteTerminalConnection({ model, serverSettings });
+    const { browsingContextId, serverSettings } = this;
+    
+    const terminal = new LiteTerminalConnection({ browsingContextId, model, serverSettings });
     terminal.disposed.connect(() => this.shutdown(name));
     return terminal;
   }
@@ -139,9 +140,9 @@ export class LiteTerminalManager
   ): Promise<Terminal.ITerminalConnection> {
     const name = options.name ?? this._nextAvailableName();
     const model: Terminal.IModel = { name };
-    const { serverSettings } = this;
+    const { browsingContextId, serverSettings } = this;
 
-    const terminal = new LiteTerminalConnection({ model, serverSettings });
+    const terminal = new LiteTerminalConnection({ browsingContextId, model, serverSettings });
     terminal.disposed.connect(() => this.shutdown(name));
     this._terminalConnections.set(name, terminal);
     await this.refreshRunning();
@@ -163,6 +164,7 @@ export class LiteTerminalManager
     }
   }
 
+  private readonly browsingContextId?: string;
   private _connectionFailure = new Signal<this, Error>(this);
   private _isReady = false;
   private _ready: Promise<void>;
@@ -172,3 +174,12 @@ export class LiteTerminalManager
     Terminal.ITerminalConnection
   >();
 }
+
+export namespace LiteTerminalManager {
+  export interface IOptions extends TerminalManager.IOptions {
+    /**
+     * The ID of the browsing context where the request originated.
+     */
+    browsingContextId?: string;
+  }
+}

src/terminal.ts

@@ -10,16 +10,18 @@ export class LiteTerminalConnection implements Terminal.ITerminalConnection {
   /**
    * Construct a new terminal session.
    */
-  constructor(options: Terminal.ITerminalConnection.IOptions) {
+  constructor(options: LiteTerminalConnection.IOptions) {
     this._name = options.model.name;
     this._serverSettings = options.serverSettings!;
     const { baseUrl } = this._serverSettings;
+    const { browsingContextId } = options;
 
     this._shell = new Shell({
       mountpoint: '/drive',
       driveFsBaseUrl: baseUrl,
       wasmBaseUrl: baseUrl + 'extensions/@jupyterlite/terminal/static/wasm/',
-      outputCallback: this._outputCallback.bind(this)
+      outputCallback: this._outputCallback.bind(this),
+      browsingContextId
     });
     this._shell.disposed.connect(() => this.dispose());
 
@@ -182,3 +184,12 @@ export class LiteTerminalConnection implements Terminal.ITerminalConnection {
 
   private _shell: IShell;
 }
+
+export namespace LiteTerminalConnection {
+  export interface IOptions extends Terminal.ITerminalConnection.IOptions {
+    /**
+     * The ID of the browsing context where the request originated.
+     */
+    browsingContextId?: string;
+  }
+}

src/worker.ts

@@ -1,51 +1,35 @@
 import { expose } from 'comlink';
 
-import { BaseShellWorker, IFileSystem } from '@jupyterlite/cockle';
-import {
-  ContentsAPI,
-  DriveFS,
-  ServiceWorkerContentsAPI
-} from '@jupyterlite/contents';
-
-/**
- * Custom DriveFS implementation using the service worker.
- */
-class MyDriveFS extends DriveFS {
-  createAPI(options: DriveFS.IOptions): ContentsAPI {
-    return new ServiceWorkerContentsAPI(
-      options.baseUrl,
-      options.driveName,
-      options.mountpoint,
-      options.FS,
-      options.ERRNO_CODES
-    );
-  }
-}
+import { BaseShellWorker, IDriveFSOptions } from '@jupyterlite/cockle';
+import { DriveFS } from '@jupyterlite/contents';
 
 /**
  * Shell web worker that uses DriveFS via service worker.
  * Note that this is not exported as it is accessed from Shell via the filename.
  */
 class ShellWorker extends BaseShellWorker {
   /**
-   * Initialize the DriveFS to mount an external file system.
+   * Initialize the DriveFS to mount an external file system, if available.
    */
-  protected override initDriveFS(
-    driveFsBaseUrl: string,
-    mountpoint: string,
-    fileSystem: IFileSystem
-  ): void {
-    console.log('Terminal initDriveFS', driveFsBaseUrl, mountpoint);
-    const { FS, ERRNO_CODES, PATH } = fileSystem;
-    const driveFS = new MyDriveFS({
-      FS,
-      PATH,
-      ERRNO_CODES,
-      baseUrl: driveFsBaseUrl,
-      driveName: '',
-      mountpoint
-    });
-    FS.mount(driveFS, {}, mountpoint);
+  protected override initDriveFS(options: IDriveFSOptions): void {
+    const { browsingContextId, driveFsBaseUrl, fileSystem, mountpoint } = options;
+    console.log('Terminal initDriveFS', driveFsBaseUrl, mountpoint, browsingContextId);
+    if (mountpoint !== '' && driveFsBaseUrl !== undefined && browsingContextId !== undefined) {
+      const { FS, ERRNO_CODES, PATH } = fileSystem;
+      const driveFS = new DriveFS({
+        FS,
+        PATH,
+        ERRNO_CODES,
+        baseUrl: driveFsBaseUrl,
+        driveName: '',
+        mountpoint,
+        browsingContextId
+      });
+      FS.mount(driveFS, {}, mountpoint);
+      console.log('Terminal connected to shared drive');
+    } else {
+      console.warn("Terminal not connected to shared drive");
+    }
   }
 }