@jupyterlite/terminal 0.1.6 → 0.2.0-a0

package/lib/terminal.js

@@ -1,101 +1,147 @@
-// Copyright (c) Jupyter Development Team.
-// Distributed under the terms of the Modified BSD License.
 import { Signal } from '@lumino/signaling';
-import { Server as WebSocketServer } from 'mock-socket';
 import { Shell } from './shell';
-export class Terminal {
+/**
+ * An implementation of a terminal interface.
+ */
+export class LiteTerminalConnection {
     /**
-     * Construct a new Terminal.
+     * Construct a new terminal session.
      */
     constructor(options) {
-        this.options = options;
-        this._disposed = new Signal(this);
         this._isDisposed = false;
-        this._running = false;
+        this._disposed = new Signal(this);
+        this._connectionStatus = 'connecting';
+        this._connectionStatusChanged = new Signal(this);
+        this._messageReceived = new Signal(this);
+        this._name = options.model.name;
+        this._serverSettings = options.serverSettings;
+        const { baseUrl } = this._serverSettings;
+        const { browsingContextId } = options;
         this._shell = new Shell({
             mountpoint: '/drive',
-            driveFsBaseUrl: options.baseUrl,
-            wasmBaseUrl: options.baseUrl + 'extensions/@jupyterlite/terminal/static/wasm/',
-            outputCallback: this._outputCallback.bind(this)
+            driveFsBaseUrl: baseUrl,
+            wasmBaseUrl: baseUrl + 'extensions/@jupyterlite/terminal/static/wasm/',
+            outputCallback: this._outputCallback.bind(this),
+            browsingContextId
         });
         this._shell.disposed.connect(() => this.dispose());
+        this._shell.start().then(() => this._updateConnectionStatus('connected'));
     }
-    _outputCallback(text) {
-        if (this._socket) {
-            const ret = JSON.stringify(['stdout', text]);
-            this._socket.send(ret);
-        }
+    /**
+     * The current connection status of the terminal connection.
+     */
+    get connectionStatus() {
+        return this._connectionStatus;
     }
+    /**
+     * A signal emitted when the terminal connection status changes.
+     */
+    get connectionStatusChanged() {
+        return this._connectionStatusChanged;
+    }
+    /**
+     * Dispose of the resources held by the session.
+     */
     dispose() {
         if (this._isDisposed) {
             return;
         }
-        console.log('Terminal.dispose');
         this._isDisposed = true;
-        if (this._socket !== undefined) {
-            // Disconnect from frontend.
-            this._socket.send(JSON.stringify(['disconnect']));
-            this._socket.close();
-            this._socket = undefined;
-        }
-        if (this._server !== undefined) {
-            this._server.close();
-            this._server = undefined;
-        }
         this._shell.dispose();
         this._disposed.emit();
+        this._updateConnectionStatus('disconnected');
+        Signal.clearData(this);
     }
+    /**
+     * A signal emitted when the session is disposed.
+     */
     get disposed() {
         return this._disposed;
     }
+    /**
+     * Test whether the session is disposed.
+     */
     get isDisposed() {
         return this._isDisposed;
     }
     /**
-     * Get the name of the terminal.
+     * A signal emitted when a message is received from the server.
+     */
+    get messageReceived() {
+        return this._messageReceived;
+    }
+    /**
+     * Get the model for the terminal session.
+     */
+    get model() {
+        return { name: this._name };
+    }
+    /**
+     * Get the name of the terminal session.
      */
     get name() {
-        return this.options.name;
+        return this._name;
     }
-    async wsConnect(url) {
-        console.log('Terminal wsConnect', url);
-        this._server = new WebSocketServer(url);
-        this._server.on('connection', async (socket) => {
-            console.log('Terminal server connection');
-            if (this._socket !== undefined) {
-                this._socket.send(JSON.stringify(['disconnect']));
-                this._socket.close();
-                this._socket = undefined;
-            }
-            this._socket = socket;
-            socket.on('message', async (message) => {
-                const data = JSON.parse(message);
-                //console.log('==> socket message', data);
-                const message_type = data[0];
-                const content = data.slice(1);
-                if (message_type === 'stdin') {
-                    await this._shell.input(content[0]);
-                }
-                else if (message_type === 'set_size') {
-                    const rows = content[0];
-                    const columns = content[1];
-                    await this._shell.setSize(rows, columns);
-                }
-            });
-            socket.on('close', () => {
-                console.log('Terminal socket close');
-            });
-            socket.on('error', () => {
-                console.log('Terminal socket error');
-            });
-            // Return handshake.
-            const res = JSON.stringify(['setup']);
-            console.log('Terminal returning handshake via socket');
-            socket.send(res);
-            if (!this._running) {
-                this._running = true;
-                await this._shell.start();
+    /**
+     * Reconnect to a terminal.
+     *
+     * #### Notes
+     * This may try multiple times to reconnect to a terminal, and will sever
+     * any existing connection.
+     */
+    async reconnect() {
+        console.log('==> LiteTerminalConnection.reconnect not implemented');
+    }
+    /**
+     * Send a message to the terminal session.
+     *
+     * #### Notes
+     * If the connection is down, the message will be queued for sending when
+     * the connection comes back up.
+     */
+    send(message) {
+        const { content } = message;
+        if (content === undefined) {
+            return;
+        }
+        switch (message.type) {
+            case 'stdin':
+                this._shell.input(content[0]); // async
+                break;
+            case 'set_size': {
+                const rows = content[0];
+                const columns = content[1];
+                this._shell.setSize(rows, columns); // async
+                break;
             }
-        });
+        }
+    }
+    /**
+     * The server settings for the session.
+     */
+    get serverSettings() {
+        return this._serverSettings;
+    }
+    /**
+     * Shut down the terminal session.
+     */
+    async shutdown() {
+        this.dispose();
+    }
+    _outputCallback(text) {
+        // 'stdout' or 'disconnect' as MessageType.
+        // Cockle is not yet using the 'disconnect'.
+        this._messageReceived.emit({ type: 'stdout', content: [text] });
+    }
+    /**
+     * Handle connection status changes.
+     */
+    _updateConnectionStatus(connectionStatus) {
+        if (this._connectionStatus === connectionStatus) {
+            return;
+        }
+        this._connectionStatus = connectionStatus;
+        // Notify others that the connection status changed.
+        this._connectionStatusChanged.emit(connectionStatus);
     }
 }

package/lib/worker.js

@@ -1,34 +1,36 @@
 import { expose } from 'comlink';
 import { BaseShellWorker } from '@jupyterlite/cockle';
-import { DriveFS, ServiceWorkerContentsAPI } from '@jupyterlite/contents';
-/**
- * Custom DriveFS implementation using the service worker.
- */
-class MyDriveFS extends DriveFS {
-    createAPI(options) {
-        return new ServiceWorkerContentsAPI(options.baseUrl, options.driveName, options.mountpoint, options.FS, options.ERRNO_CODES);
-    }
-}
+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.
      */
-    initDriveFS(driveFsBaseUrl, mountpoint, fileSystem) {
-        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);
+    initDriveFS(options) {
+        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');
+        }
     }
 }
 const worker = new ShellWorker();

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@jupyterlite/terminal",
-    "version": "0.1.6",
+    "version": "0.2.0-a0",
     "description": "A terminal for JupyterLite",
     "keywords": [
         "jupyter",
@@ -59,19 +59,19 @@
         "watch:labextension": "jupyter labextension watch ."
     },
     "dependencies": {
-        "@jupyterlab/coreutils": "^6.3.5",
-        "@jupyterlab/services": "^7.3.5",
-        "@jupyterlab/terminal": "^4.3.5",
-        "@jupyterlab/terminal-extension": "^4.3.5",
-        "@jupyterlite/cockle": "^0.0.16",
-        "@jupyterlite/contents": "^0.5.1",
-        "@jupyterlite/server": "^0.5.1",
+        "@jupyterlab/coreutils": "^6.4.2",
+        "@jupyterlab/services": "^7.4.2",
+        "@jupyterlab/terminal": "^4.4.2",
+        "@jupyterlab/terminal-extension": "^4.4.2",
+        "@jupyterlite/cockle": "^0.0.19",
+        "@jupyterlite/contents": "0.6.0-beta.0",
+        "@jupyterlite/server": "0.6.0-beta.0",
         "@lumino/coreutils": "^2.2.0",
         "mock-socket": "^9.3.1"
     },
     "devDependencies": {
-        "@jupyterlab/builder": "^4.3.5",
-        "@jupyterlab/testutils": "^4.3.5",
+        "@jupyterlab/builder": "^4.4.2",
+        "@jupyterlab/testutils": "^4.4.2",
         "@types/jest": "^29.2.0",
         "@types/json-schema": "^7.0.11",
         "@types/react": "^18.0.26",
@@ -111,9 +111,6 @@
         "extension": true,
         "outputDir": "jupyterlite_terminal/labextension"
     },
-    "jupyterlite": {
-        "liteExtension": true
-    },
     "eslintIgnore": [
         "node_modules",
         "dist",

package/src/index.ts

@@ -2,84 +2,58 @@
 // Distributed under the terms of the Modified BSD License.
 
 import {
-  JupyterLiteServer,
-  JupyterLiteServerPlugin,
-  Router
-} from '@jupyterlite/server';
+  JupyterFrontEnd,
+  JupyterFrontEndPlugin
+} from '@jupyterlab/application';
+import {
+  ITerminalManager,
+  ServiceManagerPlugin,
+  Terminal
+} from '@jupyterlab/services';
+import { IServiceWorkerManager } from '@jupyterlite/server';
 
-import { TerminalManager } from './manager';
-import { ITerminalManager } from './tokens';
+import { isILiteTerminalManager, LiteTerminalManager } from './manager';
 
 /**
- * The terminals service plugin.
+ * The terminal manager plugin, replacing the JupyterLab terminal manager.
  */
-const terminalsPlugin: JupyterLiteServerPlugin<ITerminalManager> = {
+const terminalManagerPlugin: ServiceManagerPlugin<Terminal.IManager> = {
   id: '@jupyterlite/terminal:plugin',
-  description: 'A terminal for JupyterLite',
+  description: 'A JupyterLite extension providing a custom terminal manager',
   autoStart: true,
   provides: ITerminalManager,
-  activate: async (app: JupyterLiteServer) => {
+  activate: (_: null): Terminal.IManager => {
     console.log(
       'JupyterLite extension @jupyterlite/terminal:plugin is activated!'
     );
-
-    const { serviceManager } = app;
-    const { serverSettings, terminals } = serviceManager;
-    console.log('terminals available:', terminals.isAvailable());
-    console.log('terminals ready:', terminals.isReady); // Not ready
-    console.log('terminals active:', terminals.isActive);
-
-    // Not sure this is necessary?
-    await terminals.ready;
-    console.log('terminals ready after await:', terminals.isReady); // Ready
-
-    return new TerminalManager(serverSettings.wsUrl);
+    return new LiteTerminalManager();
   }
 };
 
 /**
- * A plugin providing the routes for the terminals service
+ * A plugin that sets the browsingContextId of the terminal manager.
  */
-const terminalsRoutesPlugin: JupyterLiteServerPlugin<void> = {
-  id: '@jupyterlite/terminal:routes-plugin',
+const browsingContextIdSetter: JupyterFrontEndPlugin<void> = {
+  id: '@jupyterlite/terminal:browsing-context-id',
   autoStart: true,
+  optional: [IServiceWorkerManager],
   requires: [ITerminalManager],
-  activate: (app: JupyterLiteServer, terminalManager: ITerminalManager) => {
-    console.log(
-      'JupyterLite extension @jupyterlite/terminal:routes-plugin is activated!',
-      terminalManager
-    );
-
-    // GET /api/terminals - List the running terminals
-    app.router.get('/api/terminals', async (req: Router.IRequest) => {
-      const res = await terminalManager.listRunning();
-      // Should return last_activity for each too,
-      return new Response(JSON.stringify(res));
-    });
-
-    // POST /api/terminals - Start a terminal
-    app.router.post('/api/terminals', async (req: Router.IRequest) => {
-      const res = await terminalManager.startNew();
-      // Should return last_activity too.
-      return new Response(JSON.stringify(res));
-    });
-
-    // DELETE /api/terminals/{terminal name} - Delete a terminal
-    app.router.delete(
-      '/api/terminals/(.+)',
-      async (req: Router.IRequest, name: string) => {
-        const exists = terminalManager.has(name);
-        if (exists) {
-          await terminalManager.shutdownTerminal(name);
-        } else {
-          const msg = `The terminal session "${name}"" does not exist`;
-          console.warn(msg);
-        }
-
-        return new Response(null, { status: exists ? 204 : 404 });
+  activate: (
+    _: JupyterFrontEnd,
+    terminalManager: Terminal.IManager,
+    serviceWorkerManager?: IServiceWorkerManager
+  ): void => {
+    if (serviceWorkerManager !== undefined) {
+      if (isILiteTerminalManager(terminalManager)) {
+        const { browsingContextId } = serviceWorkerManager;
+        terminalManager.browsingContextId = browsingContextId;
+      } else {
+        console.warn(
+          'Terminal manager does not support setting browsingContextId'
+        );
       }
-    );
+    }
   }
 };
 
-export default [terminalsPlugin, terminalsRoutesPlugin];
+export default [terminalManagerPlugin, browsingContextIdSetter];