jupyterlab_ai_code_assistants_extension 1.2.41 → 1.2.45

package/README.md

@@ -27,7 +27,7 @@ Chat-panel extensions re-implement the agent loop and trail the real tool. This
 
 - **One install, every assistant** - Claude Code, Codex, Kimi, Gemini and DeepSeek from a single package, each with its own right-side panel wearing its official mark
 - **Provider registry** - assistant-specific behaviour lives in one module per assistant behind capability flags; no core file names an assistant, and adding one touches no core file
-- **Joint settings page** - one settings section covering all assistants, with a per-assistant toggle (all on by default); toggling takes effect live, no JupyterLab reload
+- **Joint settings page** - one settings section covering all assistants, with a per-assistant toggle (all on by default); toggling takes effect live, no JupyterLab reload, and a change reaches the other JupyterLab windows of the same browser
 - **Three-section side panel** - Favorites, Recent, and All projects, each scrolling independently
 - **One-click resume** - click a row to jump back into that session in a terminal; an open terminal for the project is reused instead of duplicated. Exception: a Codex or Kimi conversation started with `+`, and a Codex fork, run without an id until the CLI writes one, so a click on that row meanwhile opens a second terminal
 - **Launcher tiles** - every enabled assistant has a tile in an "AI Assistants" section of the JupyterLab Launcher (after Other, under the extension's own robot-head icon); a click opens the assistant in the file browser's current folder, resuming the folder's conversation when one exists and starting a new one otherwise, through the companion `jupyterlab_basic_terminal_extension` (installed automatically). Disable an assistant and its tile goes; disable them all and the section goes with them

package/lib/index.js

@@ -402,6 +402,39 @@ const plugin = {
                 reprobe();
             }
         });
+        // Each JupyterLab window keeps its own copy of the settings and never
+        // reads them again, and every save writes that whole copy. So a window
+        // loaded before another window changed a setting put the old value back
+        // on its next save of any setting (DEF-PANE-282). A change in this window
+        // tells the other windows of this browser, and a window also checks when
+        // it gains focus, for a save from another browser or device. Either way
+        // it reloads only when the server's copy differs from its own: a reload
+        // replaces unsaved text in an open JSON settings editor, and the check
+        // also ends the echo, because the window that saved already holds the
+        // server's copy. Still open: another browser or device whose window saves
+        // without gaining focus first, or whose focusing click is itself the
+        // change - that needs a version check in JupyterLab's settings API
+        // (DEF-PANE-283).
+        if (settingRegistry && settings) {
+            const current = settings;
+            const channel = new BroadcastChannel(PLUGIN_ID);
+            const reload = async () => {
+                try {
+                    const fetched = await settingRegistry.connector.fetch(PLUGIN_ID);
+                    if (fetched && fetched.raw !== current.raw) {
+                        await settingRegistry.reload(PLUGIN_ID);
+                    }
+                }
+                catch (err) {
+                    console.warn(`${LOG_PREFIX} could not reload settings.`, err);
+                }
+            };
+            window.addEventListener('focus', () => void reload());
+            channel.onmessage = () => void reload();
+            current.changed.connect(() => {
+                channel.postMessage('changed');
+            });
+        }
         console.log(`${LOG_PREFIX} ${live.size} of ${registry.ids.length} assistant panel(s) docked.`);
     }
 };

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "jupyterlab_ai_code_assistants_extension",
-    "version": "1.2.41",
+    "version": "1.2.45",
     "description": "A full launcher and manager for every AI code assistant in JupyterLab - Claude Code, Codex, Kimi, Gemini and DeepSeek. Start, resume, fork, switch, and clean up CLI sessions from a side panel per assistant - one click lands you in the right terminal with the assistant already running, no duplicate tabs, no UUID hunting.",
     "keywords": [
         "jupyter",

package/src/__tests__/index.spec.ts

@@ -61,6 +61,34 @@ async function flush(turns = 8): Promise<void> {
   }
 }
 
+/** jsdom has no BroadcastChannel. This one joins every window of the test
+ * process and delivers as a microtask, so `flush` settles it and, as in a
+ * browser, a sender never hears its own message. Two windows reloading each
+ * other would post forever and starve every timer, jest's own included, so
+ * past a cap no legitimate run reaches it throws instead of hanging. */
+class TestBroadcastChannel {
+  private static _open: TestBroadcastChannel[] = [];
+  private static _posted = 0;
+  onmessage: ((event: { data: unknown }) => void) | null = null;
+
+  constructor(readonly name: string) {
+    TestBroadcastChannel._open.push(this);
+  }
+
+  postMessage(data: unknown): void {
+    TestBroadcastChannel._posted += 1;
+    if (TestBroadcastChannel._posted > 1000) {
+      throw new Error('windows are reloading each other without end');
+    }
+    for (const other of TestBroadcastChannel._open) {
+      if (other !== this && other.name === this.name) {
+        queueMicrotask(() => other.onmessage?.({ data }));
+      }
+    }
+  }
+}
+(globalThis as any).BroadcastChannel = TestBroadcastChannel;
+
 describe('DEF-GUARD-139 - reconcile hands a late roster to a docked panel', () => {
   it('a panel docked before the first roster gains the root and the trash flag', async () => {
     let roster: unknown = null;
@@ -82,12 +110,16 @@ describe('DEF-GUARD-139 - reconcile hands a late roster to a docked panel', () =
       hasPlugin: () => false
     } as any;
     const settings = {
+      raw: '{}',
       composite: {},
       get: () => ({ composite: undefined, user: undefined }),
       set: async () => undefined,
       changed: new Signal<unknown, void>({})
     };
-    const settingRegistry = { load: async () => settings } as any;
+    const settingRegistry = {
+      connector: { fetch: async () => ({ raw: settings.raw }) },
+      load: async () => settings
+    } as any;
     const fileBrowser = { model: { path: 'data/raw' } } as any;
 
     await (plugin.activate as any)(
@@ -302,6 +334,10 @@ describe('ACC-LNCH-143..146 - the Launcher tile has the panel lifecycle', () =>
 });
 
 describe('ACC-PROV - the activation contract', () => {
+  /** The settings file on the server, shared by every window activated here. */
+  let serverRaw = '{}';
+  let saves = 0;
+
   /** A roster in which every assistant is present, or every one but `absent`. */
   const roster = (absent?: string): unknown => ({
     root_dir: '/srv/lab',
@@ -319,6 +355,11 @@ describe('ACC-PROV - the activation contract', () => {
     restored: [AssistantSessionsPanel, string][];
     /** How many times the status route has been asked. */
     probes: () => number;
+    /** Plugin ids passed to `ISettingRegistry.reload`, in order. */
+    reloaded: string[];
+    /** Save from this window: the server and this window hold the new copy,
+     * and `changed` fires. */
+    save: () => void;
   }
 
   interface IOptions {
@@ -377,17 +418,29 @@ describe('ACC-PROV - the activation contract', () => {
 
     const composite = options.composite;
     const userSet = new Set(options.userSet ?? Object.keys(composite ?? {}));
-    const settingRegistry = composite
+    const reloaded: string[] = [];
+    const changed = new Signal<unknown, void>({});
+    const loaded = composite && {
+      raw: serverRaw,
+      composite,
+      get: (key: string) => ({
+        composite: composite[key],
+        user: userSet.has(key) ? composite[key] : undefined
+      }),
+      set: async () => undefined,
+      changed
+    };
+    const settingRegistry = loaded
       ? ({
-          load: async () => ({
-            composite,
-            get: (key: string) => ({
-              composite: composite[key],
-              user: userSet.has(key) ? composite[key] : undefined
-            }),
-            set: async () => undefined,
-            changed: new Signal<unknown, void>({})
-          })
+          connector: { fetch: async () => ({ raw: serverRaw }) },
+          // JupyterLab's reload takes the server's copy and fires `changed`
+          // before it resolves.
+          reload: async (id: string) => {
+            reloaded.push(id);
+            loaded.raw = serverRaw;
+            changed.emit(undefined);
+          },
+          load: async () => loaded
         } as any)
       : null;
 
@@ -401,7 +454,21 @@ describe('ACC-PROV - the activation contract', () => {
       null
     );
     await flush();
-    return { app, docked, restored, probes: () => call };
+    return {
+      app,
+      docked,
+      restored,
+      probes: () => call,
+      reloaded,
+      save: () => {
+        saves += 1;
+        serverRaw = `{"saves": ${saves}}`;
+        if (loaded) {
+          loaded.raw = serverRaw;
+        }
+        changed.emit(undefined);
+      }
+    };
   }
 
   /** Every assistant, turned off. */
@@ -534,6 +601,50 @@ describe('ACC-PROV - the activation contract', () => {
     live.docked.forEach(widget => widget.dispose());
   });
 
+  it('DEF-PANE-282 - a focus with no newer save leaves the settings alone', async () => {
+    const live = await activate({ composite: {} });
+
+    // A reload fires `changed`, and an open JSON settings editor then drops
+    // its unsaved text - so a focus that brings nothing newer must not reload.
+    window.dispatchEvent(new Event('focus'));
+    await flush(32);
+    expect(live.reloaded).toEqual([]);
+
+    live.docked.forEach(widget => widget.dispose());
+  });
+
+  it('DEF-PANE-282 - a focus after another device saved reloads the settings', async () => {
+    const live = await activate({ composite: {} });
+
+    // Saved elsewhere since this window loaded; this window's next save
+    // would write the old copy back.
+    serverRaw = '{"savedElsewhere": true}';
+    window.dispatchEvent(new Event('focus'));
+    await flush(32);
+    expect(live.reloaded).toEqual([
+      'jupyterlab_ai_code_assistants_extension:plugin'
+    ]);
+
+    live.docked.forEach(widget => widget.dispose());
+  });
+
+  it('DEF-PANE-282 - a change in one window makes the other windows of the browser reload', async () => {
+    const one = await activate({ composite: {} });
+    const other = await activate({ composite: {} });
+
+    one.save();
+    await flush(32);
+    expect(other.reloaded).toEqual([
+      'jupyterlab_ai_code_assistants_extension:plugin'
+    ]);
+    // The other window's reload fires `changed` and posts in turn; the window
+    // that saved already holds the server's copy, so the echo stops there.
+    expect(one.reloaded).toEqual([]);
+
+    one.docked.forEach(widget => widget.dispose());
+    other.docked.forEach(widget => widget.dispose());
+  });
+
   it('ACC-PROV-16 - a binary installed after start gains its panel on the next probe', async () => {
     const late = PROVIDERS[2].descriptor.id;
     let present = false;
@@ -734,9 +845,11 @@ describe('ACC-SETT - settings drive the panels', () => {
         user: key in composite ? composite[key] : undefined
       }),
       set: async () => undefined,
-      changed
+      changed,
+      raw: '{}'
     };
     const settingRegistry = {
+      connector: { fetch: async () => ({ raw: settings.raw }) },
       load: async () => {
         if (options.loadThrows) {
           throw new Error('settings registry unavailable');

package/src/index.ts

@@ -502,6 +502,39 @@ const plugin: JupyterFrontEndPlugin<void> = {
       }
     });
 
+    // Each JupyterLab window keeps its own copy of the settings and never
+    // reads them again, and every save writes that whole copy. So a window
+    // loaded before another window changed a setting put the old value back
+    // on its next save of any setting (DEF-PANE-282). A change in this window
+    // tells the other windows of this browser, and a window also checks when
+    // it gains focus, for a save from another browser or device. Either way
+    // it reloads only when the server's copy differs from its own: a reload
+    // replaces unsaved text in an open JSON settings editor, and the check
+    // also ends the echo, because the window that saved already holds the
+    // server's copy. Still open: another browser or device whose window saves
+    // without gaining focus first, or whose focusing click is itself the
+    // change - that needs a version check in JupyterLab's settings API
+    // (DEF-PANE-283).
+    if (settingRegistry && settings) {
+      const current = settings;
+      const channel = new BroadcastChannel(PLUGIN_ID);
+      const reload = async (): Promise<void> => {
+        try {
+          const fetched = await settingRegistry.connector.fetch(PLUGIN_ID);
+          if (fetched && fetched.raw !== current.raw) {
+            await settingRegistry.reload(PLUGIN_ID);
+          }
+        } catch (err) {
+          console.warn(`${LOG_PREFIX} could not reload settings.`, err);
+        }
+      };
+      window.addEventListener('focus', () => void reload());
+      channel.onmessage = () => void reload();
+      current.changed.connect(() => {
+        channel.postMessage('changed');
+      });
+    }
+
     console.log(
       `${LOG_PREFIX} ${live.size} of ${registry.ids.length} assistant panel(s) docked.`
     );