jupyterlab_ai_code_assistants_extension 1.2.38 → 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/core/terminals.js

@@ -41,8 +41,8 @@ function warnLegacyCompanion() {
     // And said where the user is looking. The symptom is tabs that are simply
     // plain, which reads as a feature that was never on rather than as something
     // to fix, and a console line only reaches someone already suspecting the
-    // cause. The two neighbouring "an installed thing is wrong" announcements in
-    // this extension both pair the console line with this toast. It does not
+    // cause. The retired-extension notice in index.ts pairs its console line
+    // with a toast the same way. It does not
     // close on its own, because the condition does not go away on its own.
     Notification.warning(message, { autoClose: false });
 }

package/lib/index.js

@@ -242,7 +242,7 @@ const plugin = {
         /** Bring the docked panels in line with settings and CLI availability.
          * Both must hold for a panel to be present. */
         const reconcile = () => {
-            var _a, _b, _c, _d, _e;
+            var _a, _b, _c;
             for (const descriptor of registry.descriptors) {
                 const id = descriptor.id;
                 if (suppressed.has(id)) {
@@ -258,38 +258,26 @@ const plugin = {
                 // the server's word on each binary is final.
                 const roster = status;
                 const available = roster === null ? true : probe !== null && probe.available !== false;
-                // Enabled but binary absent must not be a silent state: the user sees
-                // a missing panel with no clue that PATH under the Jupyter server
-                // differs from their shell. Once per id, not per reconcile.
-                // Only when the probe SUCCEEDED and this provider is the one missing.
-                // Blaming PATH for a server the frontend never reached names the wrong
-                // cause; and every provider defaults to enabled, so a machine with one
-                // assistant installed would otherwise raise three toasts about assistants
-                // the user has never heard of. The console line stays for that case.
-                const chosen = (settings === null || settings === void 0 ? void 0 : settings.get(`providers.${id}.enabled`).user) !== undefined;
+                // Enabled but binary absent is logged to the console, never announced:
+                // enabled means the extension supports the assistant, not that it is
+                // installed, so a toast would name a tool the user never installed
+                // (DEF-PANE-277). Only when the probe SUCCEEDED and this provider is
+                // the one missing - blaming PATH for a server the frontend never
+                // reached names the wrong cause. Once per id, not per reconcile.
                 if (probe !== null &&
                     probe.available === false &&
                     enabled &&
-                    chosen &&
                     !warnedUnavailable.has(id)) {
                     warnedUnavailable.add(id);
                     const binary = (_b = (_a = registry.get(id)) === null || _a === void 0 ? void 0 : _a.descriptor.cliBinary) !== null && _b !== void 0 ? _b : id;
-                    const label = (_d = (_c = registry.get(id)) === null || _c === void 0 ? void 0 : _c.descriptor.label) !== null && _d !== void 0 ? _d : id;
                     console.info(`${LOG_PREFIX} "${id}" is enabled but its \`${binary}\` binary was not found on the server's PATH; panel not shown.`);
-                    // And say it where the user is looking. A console line satisfies the
-                    // comment above only for someone who already suspects the cause; the
-                    // symptom is a panel that never appears, which reads as a broken
-                    // install rather than a PATH difference between the Jupyter server
-                    // and the user's shell. The retired-extension case next door already
-                    // gets a notification, so the COMMON failure was the quiet one.
-                    Notification.warning(`${label} is enabled but \`${binary}\` was not found on the Jupyter server's PATH, so its panel is not shown.`, { autoClose: 8000 });
                 }
                 // The latch is per ABSENCE, not per page load. Once the server reports
-                // the binary present again, a later disappearance gets its own warning:
+                // the binary present again, a later disappearance gets its own line:
                 // without this, one transient absence - a CLI upgrade unlinking the
                 // binary for a moment, or an obsolete roster from an overlapping probe -
                 // permanently suppresses the real one (DEF-125). It cannot make the
-                // warning repeat while the state is unchanged, which is what the
+                // line repeat while the state is unchanged, which is what the
                 // once-per-id latch above exists to prevent: the two conditions are
                 // mutually exclusive.
                 if (probe !== null && probe.available !== false) {
@@ -302,7 +290,7 @@ const plugin = {
                         // A panel docked before the first roster was built without the
                         // server root, and cannot resolve paths until it has one.
                         if (roster !== null) {
-                            panel.setRoot((_e = roster.root_dir) !== null && _e !== void 0 ? _e : '', roster.delete_to_trash !== false);
+                            panel.setRoot((_c = roster.root_dir) !== null && _c !== void 0 ? _c : '', roster.delete_to_trash !== false);
                         }
                     }
                     else {
@@ -414,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.38",
+    "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. */
@@ -500,6 +567,84 @@ describe('ACC-PROV - the activation contract', () => {
     live.docked.forEach(widget => widget.dispose());
   });
 
+  it('DEF-PANE-277 - an enabled assistant whose binary is absent gets no panel and no toast', async () => {
+    const toasted = jest
+      .spyOn(Notification, 'warning')
+      .mockImplementation(() => '');
+    const logged = jest
+      .spyOn(console, 'info')
+      .mockImplementation(() => undefined);
+    const absent = PROVIDERS[1].descriptor.id;
+
+    // Saved explicitly, as the settings editor writes it. Enabled means the
+    // extension supports the assistant, not that it is installed.
+    const live = await activate({
+      composite: { [`providers.${absent}.enabled`]: true },
+      answers: [() => Promise.resolve(roster(absent))]
+    });
+
+    expect(
+      live.docked
+        .filter(widget => !widget.isDisposed)
+        .map(widget => widget.descriptor.id)
+    ).not.toContain(absent);
+    expect(toasted).not.toHaveBeenCalled();
+    // The reason stays in the browser console, once.
+    expect(
+      logged.mock.calls
+        .map(args => String(args[0]))
+        .filter(line => line.includes(`"${absent}"`))
+    ).toHaveLength(1);
+
+    toasted.mockRestore();
+    logged.mockRestore();
+    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;
@@ -700,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/core/terminals.ts

@@ -65,8 +65,8 @@ function warnLegacyCompanion(): void {
   // And said where the user is looking. The symptom is tabs that are simply
   // plain, which reads as a feature that was never on rather than as something
   // to fix, and a console line only reaches someone already suspecting the
-  // cause. The two neighbouring "an installed thing is wrong" announcements in
-  // this extension both pair the console line with this toast. It does not
+  // cause. The retired-extension notice in index.ts pairs its console line
+  // with a toast the same way. It does not
   // close on its own, because the condition does not go away on its own.
   Notification.warning(message, { autoClose: false });
 }

package/src/index.ts

@@ -333,46 +333,30 @@ const plugin: JupyterFrontEndPlugin<void> = {
         const roster = status;
         const available =
           roster === null ? true : probe !== null && probe.available !== false;
-        // Enabled but binary absent must not be a silent state: the user sees
-        // a missing panel with no clue that PATH under the Jupyter server
-        // differs from their shell. Once per id, not per reconcile.
-        // Only when the probe SUCCEEDED and this provider is the one missing.
-        // Blaming PATH for a server the frontend never reached names the wrong
-        // cause; and every provider defaults to enabled, so a machine with one
-        // assistant installed would otherwise raise three toasts about assistants
-        // the user has never heard of. The console line stays for that case.
-        const chosen =
-          settings?.get(`providers.${id}.enabled`).user !== undefined;
+        // Enabled but binary absent is logged to the console, never announced:
+        // enabled means the extension supports the assistant, not that it is
+        // installed, so a toast would name a tool the user never installed
+        // (DEF-PANE-277). Only when the probe SUCCEEDED and this provider is
+        // the one missing - blaming PATH for a server the frontend never
+        // reached names the wrong cause. Once per id, not per reconcile.
         if (
           probe !== null &&
           probe.available === false &&
           enabled &&
-          chosen &&
           !warnedUnavailable.has(id)
         ) {
           warnedUnavailable.add(id);
           const binary = registry.get(id)?.descriptor.cliBinary ?? id;
-          const label = registry.get(id)?.descriptor.label ?? id;
           console.info(
             `${LOG_PREFIX} "${id}" is enabled but its \`${binary}\` binary was not found on the server's PATH; panel not shown.`
           );
-          // And say it where the user is looking. A console line satisfies the
-          // comment above only for someone who already suspects the cause; the
-          // symptom is a panel that never appears, which reads as a broken
-          // install rather than a PATH difference between the Jupyter server
-          // and the user's shell. The retired-extension case next door already
-          // gets a notification, so the COMMON failure was the quiet one.
-          Notification.warning(
-            `${label} is enabled but \`${binary}\` was not found on the Jupyter server's PATH, so its panel is not shown.`,
-            { autoClose: 8000 }
-          );
         }
         // The latch is per ABSENCE, not per page load. Once the server reports
-        // the binary present again, a later disappearance gets its own warning:
+        // the binary present again, a later disappearance gets its own line:
         // without this, one transient absence - a CLI upgrade unlinking the
         // binary for a moment, or an obsolete roster from an overlapping probe -
         // permanently suppresses the real one (DEF-125). It cannot make the
-        // warning repeat while the state is unchanged, which is what the
+        // line repeat while the state is unchanged, which is what the
         // once-per-id latch above exists to prevent: the two conditions are
         // mutually exclusive.
         if (probe !== null && probe.available !== false) {
@@ -518,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.`
     );