@jupyterlite/terminal 0.1.4 → 0.1.6

package/lib/index.d.ts

@@ -1,4 +1,4 @@
 import { JupyterLiteServerPlugin } from '@jupyterlite/server';
-import { ITerminals } from './tokens';
-declare const _default: (JupyterLiteServerPlugin<ITerminals> | JupyterLiteServerPlugin<void>)[];
+import { ITerminalManager } from './tokens';
+declare const _default: (JupyterLiteServerPlugin<ITerminalManager> | JupyterLiteServerPlugin<void>)[];
 export default _default;

package/lib/index.js

@@ -1,7 +1,7 @@
 // Copyright (c) Jupyter Development Team.
 // Distributed under the terms of the Modified BSD License.
-import { ITerminals } from './tokens';
-import { Terminals } from './terminals';
+import { TerminalManager } from './manager';
+import { ITerminalManager } from './tokens';
 /**
  * The terminals service plugin.
  */
@@ -9,7 +9,7 @@ const terminalsPlugin = {
     id: '@jupyterlite/terminal:plugin',
     description: 'A terminal for JupyterLite',
     autoStart: true,
-    provides: ITerminals,
+    provides: ITerminalManager,
     activate: async (app) => {
         console.log('JupyterLite extension @jupyterlite/terminal:plugin is activated!');
         const { serviceManager } = app;
@@ -20,7 +20,7 @@ const terminalsPlugin = {
         // Not sure this is necessary?
         await terminals.ready;
         console.log('terminals ready after await:', terminals.isReady); // Ready
-        return new Terminals(serverSettings.wsUrl);
+        return new TerminalManager(serverSettings.wsUrl);
     }
 };
 /**
@@ -29,21 +29,33 @@ const terminalsPlugin = {
 const terminalsRoutesPlugin = {
     id: '@jupyterlite/terminal:routes-plugin',
     autoStart: true,
-    requires: [ITerminals],
-    activate: (app, terminals) => {
-        console.log('JupyterLite extension @jupyterlite/terminal:routes-plugin is activated!', terminals);
+    requires: [ITerminalManager],
+    activate: (app, terminalManager) => {
+        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) => {
-            const res = await terminals.list();
+            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) => {
-            const res = await terminals.startNew();
+            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, name) => {
+            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 });
+        });
     }
 };
 export default [terminalsPlugin, terminalsRoutesPlugin];

package/lib/manager.d.ts

@@ -0,0 +1,32 @@
+import { TerminalAPI } from '@jupyterlab/services';
+import { ITerminalManager } from './tokens';
+/**
+ * A class to handle requests to /api/terminals.
+ * Although this looks similar to a JupyterLab TerminalManager, it is really a class that
+ * implements the terminal REST API.
+ */
+export declare class TerminalManager implements ITerminalManager {
+    /**
+     * Construct a new TerminalManager object.
+     */
+    constructor(wsUrl: string);
+    /**
+     * Return whether the named terminal exists.
+     */
+    has(name: string): boolean;
+    /**
+     * List the running terminals.
+     */
+    listRunning(): Promise<TerminalAPI.IModel[]>;
+    /**
+     * Shutdown a terminal by name.
+     */
+    shutdownTerminal(name: string): Promise<void>;
+    /**
+     * Start a new kernel.
+     */
+    startNew(): Promise<TerminalAPI.IModel>;
+    private _nextAvailableName;
+    private _wsUrl;
+    private _terminals;
+}

package/lib/manager.js

@@ -0,0 +1,67 @@
+// Copyright (c) Jupyter Development Team.
+// Distributed under the terms of the Modified BSD License.
+import { PageConfig } from '@jupyterlab/coreutils';
+import { Terminal } from './terminal';
+/**
+ * A class to handle requests to /api/terminals.
+ * Although this looks similar to a JupyterLab TerminalManager, it is really a class that
+ * implements the terminal REST API.
+ */
+export class TerminalManager {
+    /**
+     * Construct a new TerminalManager object.
+     */
+    constructor(wsUrl) {
+        this._terminals = new Map();
+        this._wsUrl = wsUrl;
+        console.log('==> TerminalManager.constructor', this._wsUrl);
+    }
+    /**
+     * Return whether the named terminal exists.
+     */
+    has(name) {
+        return this._terminals.has(name);
+    }
+    /**
+     * List the running terminals.
+     */
+    async listRunning() {
+        const ret = [...this._terminals.values()].map(terminal => ({
+            name: terminal.name
+        }));
+        return ret;
+    }
+    /**
+     * Shutdown a terminal by name.
+     */
+    async shutdownTerminal(name) {
+        const terminal = this._terminals.get(name);
+        if (terminal !== undefined) {
+            console.log('==> TerminalManager.shutdownTerminal', name);
+            this._terminals.delete(name);
+            terminal.dispose();
+        }
+    }
+    /**
+     * Start a new kernel.
+     */
+    async startNew() {
+        const name = this._nextAvailableName();
+        console.log('==> TerminalManager.startNew', name);
+        const baseUrl = PageConfig.getBaseUrl();
+        const terminal = new Terminal({ name, baseUrl });
+        this._terminals.set(name, terminal);
+        terminal.disposed.connect(() => this.shutdownTerminal(name));
+        const url = `${this._wsUrl}terminals/websocket/${name}`;
+        await terminal.wsConnect(url);
+        return { name };
+    }
+    _nextAvailableName() {
+        for (let i = 1;; ++i) {
+            const name = `${i}`;
+            if (!this._terminals.has(name)) {
+                return name;
+            }
+        }
+    }
+}

package/lib/shell.d.ts

@@ -0,0 +1,16 @@
+import { BaseShell, IShell } from '@jupyterlite/cockle';
+/**
+ * Shell class that uses web worker that plugs into a DriveFS via the service worker.
+ */
+export declare class Shell extends BaseShell {
+    /**
+     * Instantiate a new Shell
+     *
+     * @param options The instantiation options for a new shell
+     */
+    constructor(options: IShell.IOptions);
+    /**
+     * Load the web worker.
+     */
+    protected initWorker(options: IShell.IOptions): Worker;
+}

package/lib/shell.js

@@ -0,0 +1,23 @@
+import { BaseShell } from '@jupyterlite/cockle';
+/**
+ * Shell class that uses web worker that plugs into a DriveFS via the service worker.
+ */
+export class Shell extends BaseShell {
+    /**
+     * Instantiate a new Shell
+     *
+     * @param options The instantiation options for a new shell
+     */
+    constructor(options) {
+        super(options);
+    }
+    /**
+     * Load the web worker.
+     */
+    initWorker(options) {
+        console.log('Terminal create webworker');
+        return new Worker(new URL('./worker.js', import.meta.url), {
+            type: 'module'
+        });
+    }
+}

package/lib/terminal.d.ts

@@ -1,3 +1,4 @@
+import { ISignal } from '@lumino/signaling';
 import { ITerminal } from './tokens';
 export declare class Terminal implements ITerminal {
     readonly options: ITerminal.IOptions;
@@ -6,11 +7,18 @@ export declare class Terminal implements ITerminal {
      */
     constructor(options: ITerminal.IOptions);
     private _outputCallback;
+    dispose(): void;
+    get disposed(): ISignal<this, void>;
+    get isDisposed(): boolean;
     /**
      * Get the name of the terminal.
      */
     get name(): string;
     wsConnect(url: string): Promise<void>;
+    private _disposed;
+    private _isDisposed;
+    private _server?;
     private _socket?;
     private _shell;
+    private _running;
 }

package/lib/terminal.js

@@ -1,26 +1,56 @@
 // Copyright (c) Jupyter Development Team.
 // Distributed under the terms of the Modified BSD License.
-import { Shell } from '@jupyterlite/cockle';
+import { Signal } from '@lumino/signaling';
 import { Server as WebSocketServer } from 'mock-socket';
+import { Shell } from './shell';
 export class Terminal {
     /**
      * Construct a new Terminal.
      */
     constructor(options) {
         this.options = options;
+        this._disposed = new Signal(this);
+        this._isDisposed = false;
+        this._running = false;
         this._shell = new Shell({
             mountpoint: '/drive',
             driveFsBaseUrl: options.baseUrl,
             wasmBaseUrl: options.baseUrl + 'extensions/@jupyterlite/terminal/static/wasm/',
             outputCallback: this._outputCallback.bind(this)
         });
+        this._shell.disposed.connect(() => this.dispose());
     }
-    async _outputCallback(text) {
+    _outputCallback(text) {
         if (this._socket) {
             const ret = JSON.stringify(['stdout', text]);
             this._socket.send(ret);
         }
     }
+    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();
+    }
+    get disposed() {
+        return this._disposed;
+    }
+    get isDisposed() {
+        return this._isDisposed;
+    }
     /**
      * Get the name of the terminal.
      */
@@ -28,10 +58,15 @@ export class Terminal {
         return this.options.name;
     }
     async wsConnect(url) {
-        console.log('==> Terminal.wsConnect', url);
-        const server = new WebSocketServer(url);
-        server.on('connection', async (socket) => {
-            console.log('==> server connection', this, socket);
+        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);
@@ -47,17 +82,20 @@ export class Terminal {
                     await this._shell.setSize(rows, columns);
                 }
             });
-            socket.on('close', async () => {
-                console.log('==> socket close');
+            socket.on('close', () => {
+                console.log('Terminal socket close');
             });
-            socket.on('error', async () => {
-                console.log('==> socket error');
+            socket.on('error', () => {
+                console.log('Terminal socket error');
             });
             // Return handshake.
             const res = JSON.stringify(['setup']);
-            console.log('==> Returning handshake via socket', res);
+            console.log('Terminal returning handshake via socket');
             socket.send(res);
-            await this._shell.start();
+            if (!this._running) {
+                this._running = true;
+                await this._shell.start();
+            }
         });
     }
 }

package/lib/tokens.d.ts

@@ -1,17 +1,26 @@
 import { TerminalAPI } from '@jupyterlab/services';
 import { Token } from '@lumino/coreutils';
+import { IObservableDisposable } from '@lumino/disposable';
 /**
  * The token for the Terminals service.
  */
-export declare const ITerminals: Token<ITerminals>;
+export declare const ITerminalManager: Token<ITerminalManager>;
 /**
- * An interface for the Terminals service.
+ * An interface for the TerminalManager service.
  */
-export interface ITerminals {
+export interface ITerminalManager {
+    /**
+     * Return whether the named terminal exists.
+     */
+    has(name: string): boolean;
     /**
      * List the running terminals.
      */
-    list: () => Promise<TerminalAPI.IModel[]>;
+    listRunning: () => Promise<TerminalAPI.IModel[]>;
+    /**
+     * Shutdown a terminal by name.
+     */
+    shutdownTerminal: (name: string) => Promise<void>;
     /**
      * Start a new kernel.
      */
@@ -20,7 +29,7 @@ export interface ITerminals {
 /**
  * An interface for a server-side terminal running in the browser.
  */
-export interface ITerminal {
+export interface ITerminal extends IObservableDisposable {
     /**
      * The name of the server-side terminal.
      */

package/lib/tokens.js

@@ -4,4 +4,4 @@ import { Token } from '@lumino/coreutils';
 /**
  * The token for the Terminals service.
  */
-export const ITerminals = new Token('@jupyterlite/terminal:ITerminals');
+export const ITerminalManager = new Token('@jupyterlite/terminal:ITerminalManager');

package/lib/worker.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/worker.js

@@ -0,0 +1,35 @@
+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);
+    }
+}
+/**
+ * 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.
+     */
+    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);
+    }
+}
+const worker = new ShellWorker();
+expose(worker);

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@jupyterlite/terminal",
-    "version": "0.1.4",
+    "version": "0.1.6",
     "description": "A terminal for JupyterLite",
     "keywords": [
         "jupyter",
@@ -30,12 +30,14 @@
         "url": "https://github.com/jupyterlite/terminal.git"
     },
     "scripts": {
-        "build": "jlpm build:lib && jlpm build:labextension:dev",
-        "build:prod": "jlpm clean && jlpm build:lib:prod && jlpm build:labextension",
+        "build": "jlpm build:lib && jlpm build:labextension:dev && jlpm build:webworker",
+        "build:prod": "jlpm clean && jlpm build:lib:prod && jlpm build:labextension && jlpm build:webworker:prod",
         "build:labextension": "jupyter labextension build .",
         "build:labextension:dev": "jupyter labextension build --development True .",
         "build:lib": "tsc --sourceMap",
         "build:lib:prod": "tsc",
+        "build:webworker": "webpack -c webpack.worker.config.js --env=dev",
+        "build:webworker:prod": "webpack -c webpack.worker.config.js",
         "clean": "jlpm clean:lib",
         "clean:lib": "rimraf lib tsconfig.tsbuildinfo",
         "clean:lintcache": "rimraf .eslintcache .stylelintcache",
@@ -57,19 +59,19 @@
         "watch:labextension": "jupyter labextension watch ."
     },
     "dependencies": {
-        "@jupyterlab/coreutils": "^6.2.4",
-        "@jupyterlab/services": "^7.2.4",
-        "@jupyterlab/terminal": "^4.2.4",
-        "@jupyterlab/terminal-extension": "^4.2.4",
-        "@jupyterlite/cockle": "^0.0.12",
-        "@jupyterlite/contents": "^0.4.0",
-        "@jupyterlite/server": "^0.4.0",
+        "@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",
         "@lumino/coreutils": "^2.2.0",
         "mock-socket": "^9.3.1"
     },
     "devDependencies": {
-        "@jupyterlab/builder": "^4.2.4",
-        "@jupyterlab/testutils": "^4.2.4",
+        "@jupyterlab/builder": "^4.3.5",
+        "@jupyterlab/testutils": "^4.3.5",
         "@types/jest": "^29.2.0",
         "@types/json-schema": "^7.0.11",
         "@types/react": "^18.0.26",
@@ -91,6 +93,7 @@
         "stylelint-config-standard": "^34.0.0",
         "stylelint-csstree-validator": "^3.0.0",
         "stylelint-prettier": "^4.0.0",
+        "ts-loader": "^9.5.2",
         "typescript": "~5.0.2",
         "webpack": "^5.87.0",
         "webpack-cli": "^5.1.4",
@@ -106,8 +109,7 @@
     },
     "jupyterlab": {
         "extension": true,
-        "outputDir": "jupyterlite_terminal/labextension",
-        "webpackConfig": "./webpack.extra.config.js"
+        "outputDir": "jupyterlite_terminal/labextension"
     },
     "jupyterlite": {
         "liteExtension": true

package/src/index.ts

@@ -7,17 +7,17 @@ import {
   Router
 } from '@jupyterlite/server';
 
-import { ITerminals } from './tokens';
-import { Terminals } from './terminals';
+import { TerminalManager } from './manager';
+import { ITerminalManager } from './tokens';
 
 /**
  * The terminals service plugin.
  */
-const terminalsPlugin: JupyterLiteServerPlugin<ITerminals> = {
+const terminalsPlugin: JupyterLiteServerPlugin<ITerminalManager> = {
   id: '@jupyterlite/terminal:plugin',
   description: 'A terminal for JupyterLite',
   autoStart: true,
-  provides: ITerminals,
+  provides: ITerminalManager,
   activate: async (app: JupyterLiteServer) => {
     console.log(
       'JupyterLite extension @jupyterlite/terminal:plugin is activated!'
@@ -33,7 +33,7 @@ const terminalsPlugin: JupyterLiteServerPlugin<ITerminals> = {
     await terminals.ready;
     console.log('terminals ready after await:', terminals.isReady); // Ready
 
-    return new Terminals(serverSettings.wsUrl);
+    return new TerminalManager(serverSettings.wsUrl);
   }
 };
 
@@ -43,26 +43,42 @@ const terminalsPlugin: JupyterLiteServerPlugin<ITerminals> = {
 const terminalsRoutesPlugin: JupyterLiteServerPlugin<void> = {
   id: '@jupyterlite/terminal:routes-plugin',
   autoStart: true,
-  requires: [ITerminals],
-  activate: (app: JupyterLiteServer, terminals: ITerminals) => {
+  requires: [ITerminalManager],
+  activate: (app: JupyterLiteServer, terminalManager: ITerminalManager) => {
     console.log(
       'JupyterLite extension @jupyterlite/terminal:routes-plugin is activated!',
-      terminals
+      terminalManager
     );
 
     // GET /api/terminals - List the running terminals
     app.router.get('/api/terminals', async (req: Router.IRequest) => {
-      const res = await terminals.list();
+      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 terminals.startNew();
+      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 });
+      }
+    );
   }
 };
 

package/src/manager.ts

@@ -0,0 +1,82 @@
+// Copyright (c) Jupyter Development Team.
+// Distributed under the terms of the Modified BSD License.
+
+import { PageConfig } from '@jupyterlab/coreutils';
+import { TerminalAPI } from '@jupyterlab/services';
+
+import { Terminal } from './terminal';
+import { ITerminalManager } from './tokens';
+
+/**
+ * A class to handle requests to /api/terminals.
+ * Although this looks similar to a JupyterLab TerminalManager, it is really a class that
+ * implements the terminal REST API.
+ */
+export class TerminalManager implements ITerminalManager {
+  /**
+   * Construct a new TerminalManager object.
+   */
+  constructor(wsUrl: string) {
+    this._wsUrl = wsUrl;
+    console.log('==> TerminalManager.constructor', this._wsUrl);
+  }
+
+  /**
+   * Return whether the named terminal exists.
+   */
+  has(name: string): boolean {
+    return this._terminals.has(name);
+  }
+
+  /**
+   * List the running terminals.
+   */
+  async listRunning(): Promise<TerminalAPI.IModel[]> {
+    const ret = [...this._terminals.values()].map(terminal => ({
+      name: terminal.name
+    }));
+    return ret;
+  }
+
+  /**
+   * Shutdown a terminal by name.
+   */
+  async shutdownTerminal(name: string): Promise<void> {
+    const terminal = this._terminals.get(name);
+    if (terminal !== undefined) {
+      console.log('==> TerminalManager.shutdownTerminal', name);
+      this._terminals.delete(name);
+      terminal.dispose();
+    }
+  }
+
+  /**
+   * Start a new kernel.
+   */
+  async startNew(): Promise<TerminalAPI.IModel> {
+    const name = this._nextAvailableName();
+    console.log('==> TerminalManager.startNew', name);
+    const baseUrl = PageConfig.getBaseUrl();
+    const terminal = new Terminal({ name, baseUrl });
+    this._terminals.set(name, terminal);
+
+    terminal.disposed.connect(() => this.shutdownTerminal(name));
+
+    const url = `${this._wsUrl}terminals/websocket/${name}`;
+    await terminal.wsConnect(url);
+
+    return { name };
+  }
+
+  private _nextAvailableName(): string {
+    for (let i = 1; ; ++i) {
+      const name = `${i}`;
+      if (!this._terminals.has(name)) {
+        return name;
+      }
+    }
+  }
+
+  private _wsUrl: string;
+  private _terminals: Map<string, Terminal> = new Map();
+}

package/src/shell.ts

@@ -0,0 +1,25 @@
+import { BaseShell, IShell } from '@jupyterlite/cockle';
+
+/**
+ * Shell class that uses web worker that plugs into a DriveFS via the service worker.
+ */
+export class Shell extends BaseShell {
+  /**
+   * Instantiate a new Shell
+   *
+   * @param options The instantiation options for a new shell
+   */
+  constructor(options: IShell.IOptions) {
+    super(options);
+  }
+
+  /**
+   * Load the web worker.
+   */
+  protected override initWorker(options: IShell.IOptions): Worker {
+    console.log('Terminal create webworker');
+    return new Worker(new URL('./worker.js', import.meta.url), {
+      type: 'module'
+    });
+  }
+}

package/src/terminal.ts

@@ -1,14 +1,16 @@
 // Copyright (c) Jupyter Development Team.
 // Distributed under the terms of the Modified BSD License.
 
-import { Shell } from '@jupyterlite/cockle';
+import { IShell } from '@jupyterlite/cockle';
 import { JSONPrimitive } from '@lumino/coreutils';
+import { ISignal, Signal } from '@lumino/signaling';
 
 import {
   Server as WebSocketServer,
   Client as WebSocketClient
 } from 'mock-socket';
 
+import { Shell } from './shell';
 import { ITerminal } from './tokens';
 
 export class Terminal implements ITerminal {
@@ -23,15 +25,48 @@ export class Terminal implements ITerminal {
         options.baseUrl + 'extensions/@jupyterlite/terminal/static/wasm/',
       outputCallback: this._outputCallback.bind(this)
     });
+    this._shell.disposed.connect(() => this.dispose());
   }
 
-  private async _outputCallback(text: string): Promise<void> {
+  private _outputCallback(text: string): void {
     if (this._socket) {
       const ret = JSON.stringify(['stdout', text]);
       this._socket.send(ret);
     }
   }
 
+  dispose(): void {
+    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();
+  }
+
+  get disposed(): ISignal<this, void> {
+    return this._disposed;
+  }
+
+  get isDisposed(): boolean {
+    return this._isDisposed;
+  }
+
   /**
    * Get the name of the terminal.
    */
@@ -40,12 +75,16 @@ export class Terminal implements ITerminal {
   }
 
   async wsConnect(url: string) {
-    console.log('==> Terminal.wsConnect', url);
-
-    const server = new WebSocketServer(url);
-
-    server.on('connection', async (socket: WebSocketClient) => {
-      console.log('==> server connection', this, socket);
+    console.log('Terminal wsConnect', url);
+    this._server = new WebSocketServer(url);
+
+    this._server.on('connection', async (socket: WebSocketClient) => {
+      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: any) => {
@@ -63,23 +102,30 @@ export class Terminal implements ITerminal {
         }
       });
 
-      socket.on('close', async () => {
-        console.log('==> socket close');
+      socket.on('close', () => {
+        console.log('Terminal socket close');
       });
 
-      socket.on('error', async () => {
-        console.log('==> socket error');
+      socket.on('error', () => {
+        console.log('Terminal socket error');
       });
 
       // Return handshake.
       const res = JSON.stringify(['setup']);
-      console.log('==> Returning handshake via socket', res);
+      console.log('Terminal returning handshake via socket');
       socket.send(res);
 
-      await this._shell.start();
+      if (!this._running) {
+        this._running = true;
+        await this._shell.start();
+      }
     });
   }
 
+  private _disposed = new Signal<this, void>(this);
+  private _isDisposed = false;
+  private _server?: WebSocketServer;
   private _socket?: WebSocketClient;
-  private _shell: Shell;
+  private _shell: IShell;
+  private _running = false;
 }

package/src/tokens.ts

@@ -4,22 +4,33 @@
 import { TerminalAPI } from '@jupyterlab/services';
 
 import { Token } from '@lumino/coreutils';
+import { IObservableDisposable } from '@lumino/disposable';
 
 /**
  * The token for the Terminals service.
  */
-export const ITerminals = new Token<ITerminals>(
-  '@jupyterlite/terminal:ITerminals'
+export const ITerminalManager = new Token<ITerminalManager>(
+  '@jupyterlite/terminal:ITerminalManager'
 );
 
 /**
- * An interface for the Terminals service.
+ * An interface for the TerminalManager service.
  */
-export interface ITerminals {
+export interface ITerminalManager {
+  /**
+   * Return whether the named terminal exists.
+   */
+  has(name: string): boolean;
+
   /**
    * List the running terminals.
    */
-  list: () => Promise<TerminalAPI.IModel[]>;
+  listRunning: () => Promise<TerminalAPI.IModel[]>;
+
+  /**
+   * Shutdown a terminal by name.
+   */
+  shutdownTerminal: (name: string) => Promise<void>;
 
   /**
    * Start a new kernel.
@@ -30,7 +41,7 @@ export interface ITerminals {
 /**
  * An interface for a server-side terminal running in the browser.
  */
-export interface ITerminal {
+export interface ITerminal extends IObservableDisposable {
   /**
    * The name of the server-side terminal.
    */

package/src/worker.ts

@@ -0,0 +1,53 @@
+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
+    );
+  }
+}
+
+/**
+ * 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.
+   */
+  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);
+  }
+}
+
+const worker = new ShellWorker();
+expose(worker);

package/lib/terminals.d.ts

@@ -1,22 +0,0 @@
-import { TerminalAPI } from '@jupyterlab/services';
-import { ITerminals } from './tokens';
-/**
- * A class to handle requests to /api/terminals
- */
-export declare class Terminals implements ITerminals {
-    /**
-     * Construct a new Terminals object.
-     */
-    constructor(wsUrl: string);
-    /**
-     * List the running terminals.
-     */
-    list(): Promise<TerminalAPI.IModel[]>;
-    /**
-     * Start a new kernel.
-     */
-    startNew(): Promise<TerminalAPI.IModel>;
-    private _nextAvailableName;
-    private _wsUrl;
-    private _terminals;
-}

package/lib/terminals.js

@@ -1,48 +0,0 @@
-// Copyright (c) Jupyter Development Team.
-// Distributed under the terms of the Modified BSD License.
-import { PageConfig } from '@jupyterlab/coreutils';
-import { Terminal } from './terminal';
-/**
- * A class to handle requests to /api/terminals
- */
-export class Terminals {
-    /**
-     * Construct a new Terminals object.
-     */
-    constructor(wsUrl) {
-        this._terminals = new Map();
-        this._wsUrl = wsUrl;
-        console.log('==> Terminals.constructor', this._wsUrl);
-    }
-    /**
-     * List the running terminals.
-     */
-    async list() {
-        const ret = [...this._terminals.values()].map(terminal => ({
-            name: terminal.name
-        }));
-        console.log('==> Terminals.list', ret);
-        return ret;
-    }
-    /**
-     * Start a new kernel.
-     */
-    async startNew() {
-        const name = this._nextAvailableName();
-        console.log('==> Terminals.new', name);
-        const baseUrl = PageConfig.getBaseUrl();
-        const term = new Terminal({ name, baseUrl });
-        this._terminals.set(name, term);
-        const url = `${this._wsUrl}terminals/websocket/${name}`;
-        await term.wsConnect(url);
-        return { name };
-    }
-    _nextAvailableName() {
-        for (let i = 1;; ++i) {
-            const name = `${i}`;
-            if (!this._terminals.has(name)) {
-                return name;
-            }
-        }
-    }
-}

package/src/terminals.ts

@@ -1,60 +0,0 @@
-// Copyright (c) Jupyter Development Team.
-// Distributed under the terms of the Modified BSD License.
-
-import { PageConfig } from '@jupyterlab/coreutils';
-import { TerminalAPI } from '@jupyterlab/services';
-
-import { Terminal } from './terminal';
-import { ITerminals } from './tokens';
-
-/**
- * A class to handle requests to /api/terminals
- */
-export class Terminals implements ITerminals {
-  /**
-   * Construct a new Terminals object.
-   */
-  constructor(wsUrl: string) {
-    this._wsUrl = wsUrl;
-    console.log('==> Terminals.constructor', this._wsUrl);
-  }
-
-  /**
-   * List the running terminals.
-   */
-  async list(): Promise<TerminalAPI.IModel[]> {
-    const ret = [...this._terminals.values()].map(terminal => ({
-      name: terminal.name
-    }));
-    console.log('==> Terminals.list', ret);
-    return ret;
-  }
-
-  /**
-   * Start a new kernel.
-   */
-  async startNew(): Promise<TerminalAPI.IModel> {
-    const name = this._nextAvailableName();
-    console.log('==> Terminals.new', name);
-    const baseUrl = PageConfig.getBaseUrl();
-    const term = new Terminal({ name, baseUrl });
-    this._terminals.set(name, term);
-
-    const url = `${this._wsUrl}terminals/websocket/${name}`;
-    await term.wsConnect(url);
-
-    return { name };
-  }
-
-  private _nextAvailableName(): string {
-    for (let i = 1; ; ++i) {
-      const name = `${i}`;
-      if (!this._terminals.has(name)) {
-        return name;
-      }
-    }
-  }
-
-  private _wsUrl: string;
-  private _terminals: Map<string, Terminal> = new Map();
-}