@jupyterlite/terminal 0.1.3 → 0.1.5

package/README.md

@@ -53,8 +53,8 @@ If you would like to deploy a JupyterLite site with the terminal extension, you
 As an example, this repository deploys the JupyterLite terminal to [Vercel](https://vercel.com), using the following files:
 
 - `vercel.json`: configure the COOP / COEP server headers
-- `requirements-deploy.txt`: dependencies for the JupyterLite deployment
-- `deploy.sh`: script to deploy to Vercel, using micromamba to have full control on the Python versions and isolate the build in a virtual environment
+- `deploy/requirements-deploy.txt`: dependencies for the JupyterLite deployment
+- `deploy/deploy.sh`: script to deploy to Vercel, using micromamba to have full control on the Python versions and isolate the build in a virtual environment
 
 For more information, have a look at the JupyterLite documentation: https://jupyterlite.readthedocs.io/
 
@@ -91,7 +91,8 @@ jupyter lab
 Then build a JupyterLite distribution with the extension installed:
 
 ```bash
-jupyter lite build --contents demo/contents
+cd deploy
+jupyter lite build --contents contents
 ```
 
 And serve it either using:

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,9 +9,9 @@ const terminalsPlugin = {
     id: '@jupyterlite/terminal:plugin',
     description: 'A terminal for JupyterLite',
     autoStart: true,
-    provides: ITerminals,
+    provides: ITerminalManager,
     activate: async (app) => {
-        console.log('JupyterLab extension @jupyterlite/terminal:plugin is activated!');
+        console.log('JupyterLite extension @jupyterlite/terminal:plugin is activated!');
         const { serviceManager } = app;
         const { serverSettings, terminals } = serviceManager;
         console.log('terminals available:', terminals.isAvailable());
@@ -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('JupyterLab 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/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,6 +1,7 @@
 // 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';
 export class Terminal {
     /**
@@ -8,19 +9,48 @@ export class 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.
      */
@@ -29,9 +59,14 @@ export class Terminal {
     }
     async wsConnect(url) {
         console.log('==> Terminal.wsConnect', url);
-        const server = new WebSocketServer(url);
-        server.on('connection', async (socket) => {
-            console.log('==> server connection', this, socket);
+        this._server = new WebSocketServer(url);
+        this._server.on('connection', async (socket) => {
+            console.log('==> 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 () => {
+            socket.on('close', () => {
                 console.log('==> socket close');
             });
-            socket.on('error', async () => {
+            socket.on('error', () => {
                 console.log('==> socket error');
             });
             // Return handshake.
             const res = JSON.stringify(['setup']);
             console.log('==> Returning handshake via socket', res);
             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/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@jupyterlite/terminal",
-    "version": "0.1.3",
+    "version": "0.1.5",
     "description": "A terminal for JupyterLite",
     "keywords": [
         "jupyter",
@@ -57,19 +57,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.10",
-        "@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.15",
+        "@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",

package/src/index.ts

@@ -7,20 +7,20 @@ 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(
-      'JupyterLab extension @jupyterlite/terminal:plugin is activated!'
+      'JupyterLite extension @jupyterlite/terminal:plugin is activated!'
     );
 
     const { serviceManager } = app;
@@ -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(
-      'JupyterLab extension @jupyterlite/terminal:routes-plugin is activated!',
-      terminals
+      '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 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/terminal.ts

@@ -3,6 +3,7 @@
 
 import { Shell } from '@jupyterlite/cockle';
 import { JSONPrimitive } from '@lumino/coreutils';
+import { ISignal, Signal } from '@lumino/signaling';
 
 import {
   Server as WebSocketServer,
@@ -23,15 +24,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.
    */
@@ -41,11 +75,15 @@ 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);
+    this._server = new WebSocketServer(url);
+
+    this._server.on('connection', async (socket: WebSocketClient) => {
+      console.log('==> 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,11 +101,11 @@ export class Terminal implements ITerminal {
         }
       });
 
-      socket.on('close', async () => {
+      socket.on('close', () => {
         console.log('==> socket close');
       });
 
-      socket.on('error', async () => {
+      socket.on('error', () => {
         console.log('==> socket error');
       });
 
@@ -76,10 +114,17 @@ export class Terminal implements ITerminal {
       console.log('==> Returning handshake via socket', res);
       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 _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/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();
-}