@oceanum/oceanumlab 4.7.0 → 4.7.1

package/src/index.ts

@@ -18,6 +18,9 @@ import { requestAPI } from './handler';
 import { ChatRouter, ChatRouterError, ChatMessage } from './chatRouter';
 import { reporterFor } from './progress';
 import { ConversationPin } from './conversationPin';
+import { deviceAuthPlugin } from './auth/plugin';
+import { IOceanumAuth } from './auth/tokens';
+
 import { snapshotFromIpynb, snapshotOf } from './notebookContext';
 import { notebookHost } from './notebookHost';
 import { KernelHandoff } from './kernelHandoff';
@@ -53,20 +56,27 @@ export const datamesh_connect_extension: JupyterFrontEndPlugin<void> = {
     ISettingRegistry,
     IStateDB
   ],
+  // Optional so the panel still loads on a host with no Oceanum environment; the
+  // Notebooks tab then explains why it is empty instead of the panel failing to start.
+  optional: [IOceanumAuth],
   activate: (
     app: JupyterFrontEnd,
     palette: ICommandPalette,
     restorer: ILayoutRestorer,
     status: ILabStatus,
-    settingRegistry: ISettingRegistry
+    settingRegistry: ISettingRegistry,
+    stateDB: IStateDB,
+    auth: IOceanumAuth | null
   ) => {
     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;
+    // Where the Datamesh UI and Oceanum AI live is the deployment's business, so it comes
+    // from the sign-in environment (the Jupyter server's configuration, or the notebook
+    // site's) and falls back to production. These were user settings until 4.7.1; a
+    // user-editable service address is somewhere to send the user's credential.
+    const datameshUiUrl = auth?.urls?.datameshUi ?? DATAMESH_UI_SERVICE;
+    const aiBackendUrl = auth?.urls?.ai ?? OCEANUM_AI_BACKEND_URL;
+    // The `datameshToken` setting for the AI chat; empty until the settings load.
     let datameshTokenSetting = '';
     // Tells the sidebar the settings above have changed.
     const settingsChanged = new Signal<JupyterFrontEnd, void>(app);
@@ -88,14 +98,7 @@ 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
@@ -145,7 +148,13 @@ export const datamesh_connect_extension: JupyterFrontEndPlugin<void> = {
       aiBackendUrl: () => aiBackendUrl,
       settingsChanged,
       commands: app.commands,
-      getCurrentWidget
+      getCurrentWidget,
+      auth
+      // No `openStoredNotebook`: nothing can open a spec store record by id yet.
+      // share-oceanum has `oceanum-share:open`, but it takes no arguments — it opens
+      // its own picker — so there is nothing to hand an id to. Opening arrives with
+      // the drive in OCE-182, where the contents API makes it the ordinary path.
+      // Until then the list reads rather than offering a click that does nothing.
     });
     datameshConnectWidget.id = 'datamesh-connect';
     datameshConnectWidget.title.icon = oceanumIcon;
@@ -153,8 +162,30 @@ export const datamesh_connect_extension: JupyterFrontEndPlugin<void> = {
 
     restorer.add(datameshConnectWidget, 'datamesh-connect');
 
+    // The layout restorer restores the widget's place in the shell, not fields on it,
+    // so the chosen tab is kept here. Restoring is best effort: a missing or unreadable
+    // entry just leaves the default.
+    const TAB_STATE_KEY = `${PLUGIN_ID}:tab`;
+    void stateDB
+      .fetch(TAB_STATE_KEY)
+      .then(value => {
+        if (typeof value === 'string') {
+          datameshConnectWidget.selectTab(value);
+        }
+      })
+      .catch((): void => undefined);
+    datameshConnectWidget.tabChanged.connect((_, id) => {
+      void stateDB.save(TAB_STATE_KEY, id);
+    });
+
     // Rank has been chosen somewhat arbitrarily to give priority to the running
     // sessions widget in the sidebar.
+    //
+    // Oceanum Notebook wants this panel first instead, but that is a property of that
+    // distribution rather than of the extension: in a plain JupyterLab the file browser
+    // is the primary navigation surface and displacing it would be a regression. A
+    // distribution moves it with JupyterLab's own shell user-layout settings, keyed on
+    // this widget's id, rather than this extension hard-coding one host's preference.
     app.shell.add(datameshConnectWidget, 'left', { rank: 900 });
 
     app.commands.addCommand('datamesh-ui:open', {
@@ -174,10 +205,12 @@ export const oceanum_ai_extension: JupyterFrontEndPlugin<void> = {
   id: '@oceanum/oceanumlab:ai-chat',
   autoStart: true,
   requires: [INotebookTracker, ISettingRegistry],
+  optional: [IOceanumAuth],
   activate: (
     app: JupyterFrontEnd,
     notebookTracker: INotebookTracker,
-    settingRegistry: ISettingRegistry
+    settingRegistry: ISettingRegistry,
+    auth: IOceanumAuth | null
   ) => {
     console.log('Oceanum AI chat extension is loaded');
 
@@ -197,26 +230,31 @@ 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, app.commands, async () => {
-          const open = await pin.current();
-          readFrom = open;
-          if (open) {
-            return snapshotOf(open.content);
-          }
-          const path = pin.path();
-          if (!path) {
-            return null;
-          }
-          try {
-            const file = await app.serviceManager.contents.get(path, {
-              content: true
-            });
-            return snapshotFromIpynb(file.content);
-          } catch {
-            // Gone: an answer's cells will go into a new notebook instead.
-            return null;
-          }
-        });
+        const router = new ChatRouter(
+          settings,
+          app.commands,
+          async () => {
+            const open = await pin.current();
+            readFrom = open;
+            if (open) {
+              return snapshotOf(open.content);
+            }
+            const path = pin.path();
+            if (!path) {
+              return null;
+            }
+            try {
+              const file = await app.serviceManager.contents.get(path, {
+                content: true
+              });
+              return snapshotFromIpynb(file.content);
+            } catch {
+              // Gone: an answer's cells will go into a new notebook instead.
+              return null;
+            }
+          },
+          () => auth?.urls?.ai ?? ''
+        );
         // Asked only when an answer has blocks to place: brings the
         // conversation's notebook to the front, opening it again if closed.
         const handoff = new KernelHandoff(
@@ -352,4 +390,15 @@ export const oceanum_ai_extension: JupyterFrontEndPlugin<void> = {
   }
 };
 
-export default [datamesh_connect_extension, oceanum_ai_extension];
+/**
+ * The sign-in contract, exported so another extension can provide or consume it: a Lumino
+ * token is matched by object identity, so everyone has to import this one object, and
+ * JupyterLab shares `@oceanum/oceanumlab` between extensions as a singleton module.
+ */
+export * from './auth/tokens';
+
+export default [
+  deviceAuthPlugin,
+  datamesh_connect_extension,
+  oceanum_ai_extension
+];

package/src/specStore.ts

@@ -0,0 +1,82 @@
+/**
+ * Reading the Oceanum spec store's `notebook` records.
+ *
+ * Deliberately small: only what the Stored notebooks tab needs. oceanum-notebook's
+ * share-oceanum package has a fuller client (create, update, permissions), and when
+ * sharing moves here the two should become one rather than sitting side by side.
+ */
+
+/** A spec store list entry. The list omits the notebook body. */
+export interface ISpecSummary {
+  id: string;
+  name: string;
+  description: string | null;
+  /** Set when the record is created and never updated, so this is a creation time. */
+  modified: string;
+  /** Null unless the caller created the record: the store hides other creators. */
+  creator: string | null;
+}
+
+function isSummary(value: unknown): value is ISpecSummary {
+  if (typeof value !== 'object' || value === null) {
+    return false;
+  }
+  const v = value as Record<string, unknown>;
+  return (
+    typeof v.id === 'string' &&
+    typeof v.name === 'string' &&
+    typeof v.modified === 'string'
+  );
+}
+
+/**
+ * Every notebook the signed-in user may read: their own and those shared with them.
+ *
+ * The store answers an unauthenticated caller with an empty list rather than an error,
+ * so a missing token is indistinguishable from an empty account — callers should check
+ * they are signed in before showing "no notebooks".
+ */
+export async function listNotebooks(
+  specsUrl: string,
+  token: string,
+  fetcher: typeof fetch = fetch
+): Promise<ISpecSummary[]> {
+  const url = `${specsUrl.replace(/\/+$/, '')}/specs/notebook`;
+  const response = await fetcher(url, {
+    headers: { Authorization: `Bearer ${token}` }
+  });
+  if (!response.ok) {
+    // The store answers a bad or expired token with 400, and 403 both for no access
+    // and for a record that does not exist.
+    throw new Error(`Oceanum.io returned HTTP ${response.status}.`);
+  }
+  const data = await response.json();
+  if (!Array.isArray(data)) {
+    throw new Error('Oceanum.io returned an unexpected response.');
+  }
+  return data.filter(isSummary);
+}
+
+/**
+ * Split a listing into the caller's own notebooks and the rest, newest first.
+ *
+ * The store only sends `creator` on records the caller created, so anything else it
+ * returns is shared with them — directly, or because it is public. Addresses are
+ * compared case-insensitively: the store matches entities as case-sensitive globs, so
+ * the two sides can differ in case.
+ */
+export function partitionNotebooks(
+  items: readonly ISpecSummary[],
+  email: string | null
+): { mine: ISpecSummary[]; shared: ISpecSummary[] } {
+  const me = email?.toLowerCase() ?? null;
+  const sorted = [...items].sort((a, b) =>
+    b.modified.localeCompare(a.modified)
+  );
+  const isMine = (item: ISpecSummary): boolean =>
+    me !== null && item.creator?.toLowerCase() === me;
+  return {
+    mine: sorted.filter(isMine),
+    shared: sorted.filter(item => !isMine(item))
+  };
+}

package/style/index.css

@@ -475,3 +475,161 @@
   border-top: 1px solid var(--jp-border-color2);
   margin: 0.5em 0;
 }
+
+/* Oceanum sign-in: the top-bar account control (src/auth/accountWidget.ts). */
+.oc-Account {
+  align-self: center;
+  margin: 0 8px;
+  padding: 2px 10px;
+  border: var(--jp-border-width) solid var(--jp-border-color1);
+  border-radius: 12px;
+  background: var(--jp-layout-color1);
+  color: var(--jp-ui-font-color1);
+  font-family: var(--jp-ui-font-family);
+  font-size: var(--jp-ui-font-size1);
+  white-space: nowrap;
+  cursor: pointer;
+}
+
+.oc-Account:hover {
+  background: var(--jp-layout-color2);
+}
+
+.oc-Account:not(.oc-mod-signedIn) {
+  border-color: var(--jp-brand-color1);
+  color: var(--jp-brand-color1);
+}
+
+/* The sign-in dialog: the device code, and the link that confirms it. */
+.oc-SignIn {
+  max-width: 360px;
+}
+
+.oc-SignIn-code {
+  margin: 12px 0;
+  padding: 10px;
+  border: var(--jp-border-width) solid var(--jp-border-color1);
+  border-radius: 4px;
+  background: var(--jp-layout-color2);
+  font-family: var(--jp-code-font-family);
+  font-size: 22px;
+  letter-spacing: 3px;
+  text-align: center;
+  user-select: all;
+}
+
+.oc-SignIn-link {
+  display: block;
+  padding: 6px 12px;
+  border-radius: 2px;
+  text-align: center;
+  text-decoration: none;
+}
+
+.oc-SignIn-note {
+  margin-top: 12px;
+  color: var(--jp-ui-font-color2);
+  font-size: var(--jp-ui-font-size0);
+}
+
+/* The Oceanum side panel's tab strip (src/Tabs.tsx). */
+.oceanum-tabs {
+  display: flex;
+  flex-direction: column;
+  min-height: 0;
+  flex: 1 1 auto;
+}
+
+.oceanum-tabs-strip {
+  display: flex;
+  border-bottom: var(--jp-border-width) solid var(--jp-border-color2);
+}
+
+.oceanum-tab {
+  flex: 1 1 auto;
+  padding: 6px 4px;
+  border: none;
+  border-bottom: 2px solid transparent;
+  background: transparent;
+  color: var(--jp-ui-font-color2);
+  font-family: var(--jp-ui-font-family);
+  font-size: var(--jp-ui-font-size1);
+  cursor: pointer;
+}
+
+.oceanum-tab:hover {
+  background: var(--jp-layout-color2);
+}
+
+.oceanum-tab-selected {
+  border-bottom-color: var(--jp-brand-color1);
+  color: var(--jp-ui-font-color1);
+}
+
+.oceanum-tabpanel {
+  display: flex;
+  flex-direction: column;
+  min-height: 0;
+  flex: 1 1 auto;
+  overflow: auto;
+}
+
+/* Must come after the rule above: an author `display` beats the user agent's
+ * `[hidden] { display: none }`, so without this every pane renders at once and the
+ * tabs only move the underline. */
+.oceanum-tabpanel[hidden] {
+  display: none;
+}
+
+/* Stored notebooks (src/StoredNotebooks.tsx). */
+.oceanum-notebooks-heading {
+  display: flex;
+  justify-content: space-between;
+  padding: 6px 8px 2px;
+  color: var(--jp-ui-font-color2);
+  font-size: var(--jp-ui-font-size0);
+  text-transform: uppercase;
+}
+
+.oceanum-notebooks-list {
+  margin: 0;
+  padding: 0;
+  list-style: none;
+}
+
+.oceanum-notebooks-item {
+  display: block;
+  width: 100%;
+  padding: 4px 8px;
+  border: none;
+  background: transparent;
+  color: var(--jp-ui-font-color1);
+  font-family: var(--jp-ui-font-family);
+  font-size: var(--jp-ui-font-size1);
+  text-align: left;
+  cursor: pointer;
+}
+
+.oceanum-notebooks-item:hover {
+  background: var(--jp-layout-color2);
+}
+
+.oceanum-notebooks-item-static {
+  cursor: default;
+}
+
+.oceanum-notebooks-item-static:hover {
+  background: transparent;
+}
+
+.oceanum-notebooks-name {
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+
+.oceanum-text-error {
+  padding: 8px;
+  color: var(--jp-error-color1);
+  font-size: var(--jp-ui-font-size1);
+}