@oceanum/oceanumlab 4.6.1 → 4.7.0

package/src/chatRouter.ts

@@ -1,5 +1,11 @@
 import { ISettingRegistry } from '@jupyterlab/settingregistry';
-import { OCEANUM_AI_BACKEND_URL } from './constants';
+import {
+  aiBackendUrl,
+  canSignIn,
+  resolveAiCredential,
+  signInToken,
+  type AuthCommands
+} from './aiBackend';
 import type { Progress } from './progress';
 import { readSse } from './sse';
 import type { ObservedRun } from './notebookRun';
@@ -76,6 +82,8 @@ function asOceanumResponse(data: unknown): OceanumResponse {
 
 export class ChatRouter {
   /**
+   * @param _commands Where the host's Oceanum.io sign-in is asked for, when
+   *   there is no pasted Datamesh token.
    * @param _notebook What the conversation's notebook holds -- the one its
    *   answers are placed in -- or null if there is nothing to send. Asked on
    *   every request, so it follows the conversation rather than whichever tab
@@ -83,6 +91,7 @@ export class ChatRouter {
    */
   constructor(
     private _settings: ISettingRegistry.ISettings,
+    private _commands: AuthCommands,
     private _notebook: () => Promise<INotebookSnapshot | null>
   ) {}
 
@@ -178,20 +187,30 @@ export class ChatRouter {
     signal?: AbortSignal,
     onProgress?: (progress: Progress) => void
   ): Promise<unknown> {
-    const token = this._settings.get('datameshToken').composite as string;
-    if (!token) {
+    // Resolved per request, not once: the sign-in token refreshes, and the
+    // user can sign in, sign out or paste a token between two requests.
+    const credential = await resolveAiCredential(
+      this._settings.get('datameshToken').composite,
+      signInToken(this._commands)
+    );
+    if (!credential) {
       throw new ChatRouterError(
-        'Datamesh token not configured. Set your token in Settings → Oceanum.io.'
+        canSignIn(this._commands)
+          ? 'Not signed in. Sign in to Oceanum.io to use Oceanum AI, or set a Datamesh token in Settings → Oceanum.io.'
+          : 'Datamesh token not configured. Set your token in Settings → Oceanum.io.'
       );
     }
+    const backend = aiBackendUrl(
+      this._settings.get('aiBackendUrl').composite as string
+    );
 
     let response: Response;
     try {
-      response = await fetch(`${OCEANUM_AI_BACKEND_URL}${path}`, {
+      response = await fetch(`${backend}${path}`, {
         method: 'POST',
         headers: {
           'Content-Type': 'application/json',
-          'X-Datamesh-Token': token,
+          ...credential.headers,
           // Ask for the streamed form only when someone is listening. The
           // server requires the media type to be NAMED -- a wildcard never
           // selects it -- so omitting this is what keeps the plain JSON path
@@ -208,12 +227,21 @@ export class ChatRouter {
         throw err;
       }
       throw new ChatRouterError(
-        `Could not reach Oceanum AI backend at ${OCEANUM_AI_BACKEND_URL}. Is it running?`
+        `Could not reach Oceanum AI backend at ${backend}. Is it running?`
       );
     }
 
     if (response.status === 401) {
-      throw new ChatRouterError('Invalid or expired Datamesh token.', 401);
+      let message = 'Invalid or expired Datamesh token.';
+      if (credential.source === 'sign-in') {
+        message =
+          'Your Oceanum.io sign-in was not accepted. Sign in to Oceanum.io again.';
+      } else if (canSignIn(this._commands)) {
+        // A pasted token wins over the sign-in, so say how to fall back to it.
+        message +=
+          ' Update it, or clear it to use your Oceanum.io sign-in, in Settings → Oceanum.io.';
+      }
+      throw new ChatRouterError(message, 401);
     }
 
     if (!response.ok) {

package/src/constants.ts

@@ -3,7 +3,7 @@
  * These values are compiled into the extension.
  */
 
-/** URL of the Oceanum AI backend service */
+/** Default URL of the Oceanum AI backend service (the `aiBackendUrl` setting) */
 export const OCEANUM_AI_BACKEND_URL = 'https://ai.oceanum.io';
 
 /** URL of the Datamesh UI embedded in the Datamesh panel */

package/src/datameshUiUrl.ts

@@ -0,0 +1,44 @@
+/**
+ * The Datamesh UI panel's address, and which messages may come from it.
+ *
+ * The address is a setting (`datameshUiUrl`), so a deployment can point the
+ * panel at another Datamesh UI -- a dev one, say. A setting is typed in by
+ * hand, so anything that is not an http(s) URL falls back to the default
+ * rather than ending up in an iframe's `src`.
+ */
+import { DATAMESH_UI_SERVICE } from './constants';
+import { validHttpUrl } from './httpUrl';
+
+/** The Datamesh UI address to use for a `datameshUiUrl` setting value. */
+export function validDatameshUiUrl(url: string | null | undefined): URL {
+  return validHttpUrl(url, DATAMESH_UI_SERVICE);
+}
+
+/**
+ * The panel's iframe `src`: the Datamesh UI in embed mode, which hides the
+ * Oceanum.io navigator. Any query the setting already has is kept.
+ */
+export function datameshUiSrc(url: string | null | undefined): string {
+  const src = validDatameshUiUrl(url);
+  src.searchParams.set('embed', '1');
+  return src.toString();
+}
+
+/**
+ * Whether a `message` event was posted by the Datamesh UI panel.
+ *
+ * Any page or frame can post to this window, so a message counts only when it
+ * comes from the panel's iframe (`frame`, its `contentWindow`; `null` when the
+ * panel is not open) and from the configured Datamesh UI's origin.
+ */
+export function isDatameshUiMessage(
+  event: Pick<MessageEvent, 'origin' | 'source'>,
+  url: string | null | undefined,
+  frame: Window | null
+): boolean {
+  return (
+    !!frame &&
+    event.source === frame &&
+    event.origin === validDatameshUiUrl(url).origin
+  );
+}

package/src/httpUrl.ts

@@ -0,0 +1,23 @@
+/**
+ * An address typed into a setting, checked before anything uses it.
+ *
+ * A setting is typed in by hand, so anything that is not an http(s) URL falls
+ * back to the default rather than ending up in an iframe's `src` or a
+ * request's address.
+ */
+
+/** `value` as an http(s) URL, or `fallback` when it is empty or not one. */
+export function validHttpUrl(
+  value: string | null | undefined,
+  fallback: string
+): URL {
+  try {
+    const parsed = new URL((value ?? '').trim());
+    if (parsed.protocol === 'https:' || parsed.protocol === 'http:') {
+      return parsed;
+    }
+  } catch {
+    // Empty or not a URL: the default below.
+  }
+  return new URL(fallback);
+}

package/src/index.ts

@@ -7,6 +7,7 @@ import {
 import { ICommandPalette, Notification } from '@jupyterlab/apputils';
 import { LabIcon } from '@jupyterlab/ui-components';
 import { find } from '@lumino/algorithm';
+import { Signal } from '@lumino/signaling';
 import { Widget } from '@lumino/widgets';
 import { ISettingRegistry } from '@jupyterlab/settingregistry';
 import { IStateDB } from '@jupyterlab/statedb';
@@ -21,7 +22,11 @@ import { snapshotFromIpynb, snapshotOf } from './notebookContext';
 import { notebookHost } from './notebookHost';
 import { KernelHandoff } from './kernelHandoff';
 import { runChatLoop, STOPPED } from './aiLoop';
-import { MAX_OBSERVE_ROUNDS } from './constants';
+import {
+  DATAMESH_UI_SERVICE,
+  MAX_OBSERVE_ROUNDS,
+  OCEANUM_AI_BACKEND_URL
+} from './constants';
 
 import '../style/index.css';
 
@@ -57,6 +62,21 @@ export const datamesh_connect_extension: JupyterFrontEndPlugin<void> = {
   ) => {
     console.log('Oceanum datamesh connect extension is loaded');
 
+    // The `datameshUiUrl` setting; the default until the settings load.
+    let datameshUiUrl = DATAMESH_UI_SERVICE;
+    // The `aiBackendUrl` and `datameshToken` settings for the AI chat; the
+    // defaults until the settings load.
+    let aiBackendUrl = OCEANUM_AI_BACKEND_URL;
+    let datameshTokenSetting = '';
+    // Tells the sidebar the settings above have changed.
+    const settingsChanged = new Signal<JupyterFrontEnd, void>(app);
+
+    const findDatameshUI = (): DatameshUI | undefined =>
+      find(
+        app.shell.widgets('main'),
+        (widget: Widget) => widget.id === 'datamesh-ui'
+      ) as DatameshUI | undefined;
+
     //Try to get the datamesh token from the settings
     const updateSettings = (set: ISettingRegistry.ISettings) => {
       const token = set.get('datameshToken');
@@ -68,6 +88,15 @@ export const datamesh_connect_extension: JupyterFrontEndPlugin<void> = {
         }).then(res => console.log(res));
       }
       window.injectToken = set.get('injectToken').user as boolean;
+      aiBackendUrl = set.get('aiBackendUrl').composite as string;
+      datameshTokenSetting = set.get('datameshToken').composite as string;
+      // An open Datamesh UI panel follows a change of address.
+      datameshUiUrl = set.get('datameshUiUrl').composite as string;
+      const datameshUI = findDatameshUI();
+      if (datameshUI) {
+        datameshUI.url = datameshUiUrl;
+      }
+      settingsChanged.emit();
     };
     //Try to get the datamesh token from the envars
 
@@ -91,18 +120,12 @@ export const datamesh_connect_extension: JupyterFrontEndPlugin<void> = {
 
     const openDatameshUI = (event: any): void => {
       const widgetId = 'datamesh-ui';
-      const openWidget = find(
-        app.shell.widgets('main'),
-        (widget: Widget, index: number) => {
-          return widget.id === widgetId;
-        }
-      );
-      if (openWidget) {
+      if (findDatameshUI()) {
         app.shell.activateById(widgetId);
         return;
       }
 
-      const datameshUIWidget = new DatameshUI();
+      const datameshUIWidget = new DatameshUI(datameshUiUrl);
       datameshUIWidget.title.label = 'Oceanum Datamesh';
       datameshUIWidget.id = widgetId;
       datameshUIWidget.title.closable = true;
@@ -116,6 +139,11 @@ export const datamesh_connect_extension: JupyterFrontEndPlugin<void> = {
       name: 'Datamesh Connect',
       icon: oceanumIcon,
       openDatameshUI: openDatameshUI,
+      datameshUiUrl: () => datameshUiUrl,
+      datameshUiFrame: () => findDatameshUI()?.frame ?? null,
+      datameshToken: () => datameshTokenSetting,
+      aiBackendUrl: () => aiBackendUrl,
+      settingsChanged,
       commands: app.commands,
       getCurrentWidget
     });
@@ -169,7 +197,7 @@ export const oceanum_ai_extension: JupyterFrontEndPlugin<void> = {
         // The panel the current request read its selected cell from, if the
         // notebook was open: a code answer may replace that cell only there.
         let readFrom: NotebookPanel | null = null;
-        const router = new ChatRouter(settings, async () => {
+        const router = new ChatRouter(settings, app.commands, async () => {
           const open = await pin.current();
           readFrom = open;
           if (open) {