jupyterlab_ai_code_assistants_extension 1.0.32 → 1.0.39

package/lib/core/panel.d.ts

@@ -85,6 +85,18 @@ export declare class AssistantSessionsPanel extends Widget {
      * `resolveLaunchMode` for the precedence rule. */
     private _launchMode;
     private _openSession;
+    /** The server root every path is shown and resolved against, plus
+     * JupyterLab's move-to-trash setting. Settable because a panel docked before
+     * the server has answered its first status probe is built without either
+     * (DEF-132); the action paths read them lazily, so a late value applies on
+     * the next click, while rows already rendered keep absolute paths until the
+     * next poll.
+     *
+     * Trailing slashes go, but never the root itself: serving JupyterLab at
+     * `/` used to normalise to the empty string, which reads as "no root" -
+     * the + button then did nothing at all, and Open Terminal and Show in File
+     * Browser answered "outside the JupyterLab root" for every row inside it. */
+    setRoot(rootDir: string, deleteToTrash: boolean): void;
     /** Absolute path of the file browser's current folder; the server root when
      * no file browser is available. */
     private _currentFolder;
@@ -271,8 +283,8 @@ export declare class AssistantSessionsPanel extends Widget {
     private readonly _descriptor;
     private readonly _hooks;
     private readonly _serverSettings;
-    private readonly _rootDir;
-    private readonly _deleteToTrash;
+    private _rootDir;
+    private _deleteToTrash;
     private readonly _fileBrowser;
     private readonly _colours;
     private readonly _terminals;

package/lib/core/panel.js

@@ -94,6 +94,8 @@ export class AssistantSessionsPanel extends Widget {
     constructor(options) {
         var _a, _b, _c, _d;
         super();
+        this._rootDir = '';
+        this._deleteToTrash = true;
         this._removingPaths = new Set();
         this._loadingEl = null;
         this._errorEl = null;
@@ -132,13 +134,7 @@ export class AssistantSessionsPanel extends Widget {
         this._descriptor = options.descriptor;
         this._hooks = (_a = options.hooks) !== null && _a !== void 0 ? _a : {};
         this._serverSettings = options.app.serviceManager.serverSettings;
-        // Trailing slashes go, but never the root itself: serving JupyterLab at
-        // `/` used to normalise to the empty string, which reads as "no root" -
-        // the + button then did nothing at all, and Open Terminal and Show in File
-        // Browser answered "outside the JupyterLab root" for every row inside it.
-        const root = (options.rootDir || '').replace(/\/+$/, '');
-        this._rootDir = root || (options.rootDir ? '/' : '');
-        this._deleteToTrash = options.deleteToTrash !== false;
+        this.setRoot(options.rootDir, options.deleteToTrash !== false);
         this._fileBrowser = (_b = options.fileBrowser) !== null && _b !== void 0 ? _b : null;
         this._expandedKey = `jupyterlab_ai_code_assistants_extension:${this._descriptor.id}:expanded`;
         this._expanded = loadExpanded(this._expandedKey);
@@ -259,8 +255,15 @@ export class AssistantSessionsPanel extends Widget {
         // and this button LAUNCHES on click instead of dropping a menu, so without
         // the suffix the one surface that starts an approval-free session is the
         // only one that never says so (DEF-36, DEF-113, DEF-114).
+        // Disabled, not silent, while the server root is unknown (a panel docked
+        // before the first status roster, DEF-132): a healthy-looking button that
+        // does nothing on click cannot be diagnosed by the user. `setRoot` re-runs
+        // this once the root lands, so the state is data-driven, not timed.
         const nameNewButton = () => {
-            newBtn.title = `New session in current folder${this._variantSuffix()}`;
+            newBtn.disabled = !this._rootDir;
+            newBtn.title = this._rootDir
+                ? `New session in current folder${this._variantSuffix()}`
+                : 'Waiting for the server root';
         };
         // Focus as well as hover, or the icon-only button's accessible name is the
         // generic one for everybody not using a mouse.
@@ -707,10 +710,33 @@ export class AssistantSessionsPanel extends Widget {
             void this._fetch().catch(() => undefined);
         }
     }
+    /** The server root every path is shown and resolved against, plus
+     * JupyterLab's move-to-trash setting. Settable because a panel docked before
+     * the server has answered its first status probe is built without either
+     * (DEF-132); the action paths read them lazily, so a late value applies on
+     * the next click, while rows already rendered keep absolute paths until the
+     * next poll.
+     *
+     * Trailing slashes go, but never the root itself: serving JupyterLab at
+     * `/` used to normalise to the empty string, which reads as "no root" -
+     * the + button then did nothing at all, and Open Terminal and Show in File
+     * Browser answered "outside the JupyterLab root" for every row inside it. */
+    setRoot(rootDir, deleteToTrash) {
+        var _a;
+        const root = (rootDir || '').replace(/\/+$/, '');
+        this._rootDir = root || (rootDir ? '/' : '');
+        this._deleteToTrash = deleteToTrash;
+        (_a = this._renameNewButton) === null || _a === void 0 ? void 0 : _a.call(this);
+    }
     /** Absolute path of the file browser's current folder; the server root when
      * no file browser is available. */
     _currentFolder() {
         var _a, _b, _c;
+        // No roster yet (DEF-132): a relative folder joined to an empty root
+        // would be an absolute path at the filesystem root.
+        if (!this._rootDir) {
+            return '';
+        }
         const rel = ((_c = (_b = (_a = this._fileBrowser) === null || _a === void 0 ? void 0 : _a.model) === null || _b === void 0 ? void 0 : _b.path) !== null && _c !== void 0 ? _c : '').replace(/^\/+/, '');
         if (!rel) {
             return this._rootDir;

package/lib/index.js

@@ -64,34 +64,27 @@ const plugin = {
         let status = null;
         let settings = null;
         let sidebar = DEFAULT_SIDEBAR;
-        let probeGeneration = 0;
         /** Ask the server which providers exist and which of their binaries are on
-         * PATH. An unsuperseded failure leaves the extension activated with no
-         * panels until a later probe succeeds - never a dialog, never a thrown
-         * activation.
+         * PATH.
          *
-         * Probes overlap: a probe can outlive one issued after it, so verdicts do
-         * not arrive in the order they were asked for. A ROSTER is always written,
-         * whichever settles last - both are answers from the same server, and the
-         * loser is at worst one client deadline stale (DEF-125). A FAILURE is not an answer, so it
-         * is written only while no newer probe has been issued; otherwise a
-         * timeout could discard a roster the server has since confirmed, undocking
-         * every panel while it is healthy (DEF-121). No request is suppressed. */
+         * `status` is the last roster the server gave, and null means it has never
+         * given one - two different facts that used to share one value. A probe
+         * that FAILS writes nothing: not answering is not an answer, and reading it
+         * as "no assistant is installed" is what emptied the sidebar on every
+         * reload whose first request landed before the server was listening
+         * (DEF-132), and on every wake whose probe fired before the network was
+         * back (DEF-119). No request is suppressed, and a failure never needs
+         * ordering against a success, because it has nothing to write. */
         const probeStatus = async () => {
-            const mine = ++probeGeneration;
             try {
                 status = await requestAPI('status', serverSettings, {
                     cache: 'no-store'
                 });
             }
             catch (err) {
-                // No cadence named here: this also prints from the activation probe,
-                // and neither the interval nor the wake listeners are armed until
-                // after `await migrate()` below (DEF-122).
-                console.warn(`${LOG_PREFIX} status probe failed; panels dock again once a later probe succeeds.`, err);
-                if (mine === probeGeneration) {
-                    status = null;
-                }
+                // No cadence named: this also prints from the activation probe, before
+                // the interval and the wake listeners are armed (DEF-122).
+                console.warn(`${LOG_PREFIX} status probe failed; the last known roster stands (every enabled assistant, when there is none yet) until a later probe answers.`, err);
             }
         };
         const statusFor = (id) => { var _a, _b; return (_b = (_a = status === null || status === void 0 ? void 0 : status.providers) === null || _a === void 0 ? void 0 : _a.find(p => p.id === id)) !== null && _b !== void 0 ? _b : null; };
@@ -153,7 +146,10 @@ const plugin = {
                     descriptor: module.descriptor,
                     hooks: module.hooks,
                     rootDir: (_a = status === null || status === void 0 ? void 0 : status.root_dir) !== null && _a !== void 0 ? _a : '',
-                    deleteToTrash: (status === null || status === void 0 ? void 0 : status.delete_to_trash) !== false,
+                    // Unknown reads as "not trash": the popup then arms its Delete
+                    // button before it executes, which is the only confirmation a
+                    // permanent bulk delete has (DEF-135).
+                    deleteToTrash: status ? status.delete_to_trash !== false : false,
                     terminalTracker,
                     fileBrowser,
                     colourfulTabs
@@ -188,7 +184,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;
+            var _a, _b, _c, _d, _e;
             for (const descriptor of registry.descriptors) {
                 const id = descriptor.id;
                 if (suppressed.has(id)) {
@@ -196,16 +192,22 @@ const plugin = {
                 }
                 const enabled = setting(`providers.${id}.enabled`, true) !== false;
                 const probe = statusFor(id);
-                const available = probe ? probe.available !== false : false;
+                // Unknown is not absent. With no roster yet, an enabled assistant is
+                // docked: JupyterLab restores the sidebar tab it had open only if that
+                // tab exists when activation ends, and it waits for activation but
+                // not for a later probe - so a panel that arrives a minute late is one
+                // the layout has already given up on (DEF-132). Once a roster exists
+                // 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.
-                // A failed probe sets every provider unavailable, and 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.
+                // 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;
                 if (probe !== null &&
                     probe.available === false &&
@@ -226,7 +228,13 @@ const plugin = {
                 }
                 if (enabled && available) {
                     if (live.has(id)) {
-                        applySharedSettings(live.get(id).panel);
+                        const panel = live.get(id).panel;
+                        applySharedSettings(panel);
+                        // 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);
+                        }
                     }
                     else {
                         start(id);
@@ -323,8 +331,8 @@ const plugin = {
             void probeStatus().then(reconcile);
         }, STATUS_INTERVAL_MS);
         // A suspended network stack - laptop asleep, tab backgrounded - is exactly
-        // when the probe fails, and the slow cadence above would leave the sidebar
-        // panel-less for up to a minute after the machine comes back. A wake fires
+        // when the probe fails, and the slow cadence above would leave the roster
+        // stale for up to a minute after the machine comes back. A wake fires
         // both events, so it costs two probes; deliberately, because a guard that
         // let the second join the first answered the wake with a request issued
         // before it, and starved the interval above of its own tick (DEF-117).

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "jupyterlab_ai_code_assistants_extension",
-    "version": "1.0.32",
+    "version": "1.0.39",
     "description": "Jupyterlab extension to replace individual jupyterlab_*_code_extension and integrate into one, that offers joint capability, joint settings page and individual right toolbar panels per code assistant, with the ability in settings to decide which code assistant support is on (default - all are enabled)",
     "keywords": [
         "jupyter",

package/src/__tests__/panel.spec.ts

@@ -622,3 +622,43 @@ describe('DEF-46 - the row tooltip names only a mode the row launches with', ()
     expect(text).not.toContain('Launch mode');
   });
 });
+
+describe('DEF-132 - a panel docked before the first roster has no root', () => {
+  function rootless(): AssistantSessionsPanel {
+    return new AssistantSessionsPanel({
+      app: {
+        serviceManager: { serverSettings: {} },
+        commands: { execute: jest.fn() }
+      } as any,
+      descriptor: { ...DESCRIPTOR, iconName: 'testbed-rootless-panel-spec' },
+      rootDir: '',
+      fileBrowser: { model: { path: 'data/raw' } } as any
+    });
+  }
+
+  it('the + button is inert until setRoot supplies the root', async () => {
+    const p = rootless();
+    await flush();
+    request.mockClear();
+
+    // Without the guard this is `/data/raw` - a folder at the filesystem
+    // root, which the server accepts whenever it happens to exist.
+    expect((p as any)._currentFolder()).toBe('');
+    await (p as any)._newSession();
+    expect(request).not.toHaveBeenCalled();
+    // And the button says so, rather than looking live and doing nothing.
+    const newBtn = p.node.querySelector<HTMLButtonElement>(
+      '.jp-AiAssistantsPanel-iconButton'
+    )!;
+    expect(newBtn.disabled).toBe(true);
+    expect(newBtn.title).toBe('Waiting for the server root');
+
+    p.setRoot('/srv/lab/', true);
+    expect((p as any)._currentFolder()).toBe('/srv/lab/data/raw');
+    expect(newBtn.disabled).toBe(false);
+    expect(newBtn.title).toMatch(/^New session in current folder/);
+    p.setRoot('/', true);
+    expect((p as any)._currentFolder()).toBe('/data/raw');
+    p.dispose();
+  });
+});

package/src/core/panel.ts

@@ -171,13 +171,7 @@ export class AssistantSessionsPanel extends Widget {
     this._descriptor = options.descriptor;
     this._hooks = options.hooks ?? {};
     this._serverSettings = options.app.serviceManager.serverSettings;
-    // Trailing slashes go, but never the root itself: serving JupyterLab at
-    // `/` used to normalise to the empty string, which reads as "no root" -
-    // the + button then did nothing at all, and Open Terminal and Show in File
-    // Browser answered "outside the JupyterLab root" for every row inside it.
-    const root = (options.rootDir || '').replace(/\/+$/, '');
-    this._rootDir = root || (options.rootDir ? '/' : '');
-    this._deleteToTrash = options.deleteToTrash !== false;
+    this.setRoot(options.rootDir, options.deleteToTrash !== false);
     this._fileBrowser = options.fileBrowser ?? null;
     this._expandedKey = `jupyterlab_ai_code_assistants_extension:${this._descriptor.id}:expanded`;
     this._expanded = loadExpanded(this._expandedKey);
@@ -323,8 +317,15 @@ export class AssistantSessionsPanel extends Widget {
     // and this button LAUNCHES on click instead of dropping a menu, so without
     // the suffix the one surface that starts an approval-free session is the
     // only one that never says so (DEF-36, DEF-113, DEF-114).
+    // Disabled, not silent, while the server root is unknown (a panel docked
+    // before the first status roster, DEF-132): a healthy-looking button that
+    // does nothing on click cannot be diagnosed by the user. `setRoot` re-runs
+    // this once the root lands, so the state is data-driven, not timed.
     const nameNewButton = (): void => {
-      newBtn.title = `New session in current folder${this._variantSuffix()}`;
+      newBtn.disabled = !this._rootDir;
+      newBtn.title = this._rootDir
+        ? `New session in current folder${this._variantSuffix()}`
+        : 'Waiting for the server root';
     };
     // Focus as well as hover, or the icon-only button's accessible name is the
     // generic one for everybody not using a mouse.
@@ -841,9 +842,32 @@ export class AssistantSessionsPanel extends Widget {
     }
   }
 
+  /** The server root every path is shown and resolved against, plus
+   * JupyterLab's move-to-trash setting. Settable because a panel docked before
+   * the server has answered its first status probe is built without either
+   * (DEF-132); the action paths read them lazily, so a late value applies on
+   * the next click, while rows already rendered keep absolute paths until the
+   * next poll.
+   *
+   * Trailing slashes go, but never the root itself: serving JupyterLab at
+   * `/` used to normalise to the empty string, which reads as "no root" -
+   * the + button then did nothing at all, and Open Terminal and Show in File
+   * Browser answered "outside the JupyterLab root" for every row inside it. */
+  setRoot(rootDir: string, deleteToTrash: boolean): void {
+    const root = (rootDir || '').replace(/\/+$/, '');
+    this._rootDir = root || (rootDir ? '/' : '');
+    this._deleteToTrash = deleteToTrash;
+    this._renameNewButton?.();
+  }
+
   /** Absolute path of the file browser's current folder; the server root when
    * no file browser is available. */
   private _currentFolder(): string {
+    // No roster yet (DEF-132): a relative folder joined to an empty root
+    // would be an absolute path at the filesystem root.
+    if (!this._rootDir) {
+      return '';
+    }
     const rel = (this._fileBrowser?.model?.path ?? '').replace(/^\/+/, '');
     if (!rel) {
       return this._rootDir;
@@ -2603,8 +2627,8 @@ export class AssistantSessionsPanel extends Widget {
   private readonly _descriptor: IProviderDescriptor;
   private readonly _hooks: IProviderHooks;
   private readonly _serverSettings: ServerConnection.ISettings;
-  private readonly _rootDir: string;
-  private readonly _deleteToTrash: boolean;
+  private _rootDir = '';
+  private _deleteToTrash = true;
   private readonly _fileBrowser: IDefaultFileBrowser | null;
   private readonly _colours: ColourStore;
   private readonly _terminals: TerminalManager;

package/src/index.ts

@@ -116,37 +116,29 @@ const plugin: JupyterFrontEndPlugin<void> = {
     let settings: ISettingRegistry.ISettings | null = null;
     let sidebar: Sidebar = DEFAULT_SIDEBAR;
 
-    let probeGeneration = 0;
-
     /** Ask the server which providers exist and which of their binaries are on
-     * PATH. An unsuperseded failure leaves the extension activated with no
-     * panels until a later probe succeeds - never a dialog, never a thrown
-     * activation.
+     * PATH.
      *
-     * Probes overlap: a probe can outlive one issued after it, so verdicts do
-     * not arrive in the order they were asked for. A ROSTER is always written,
-     * whichever settles last - both are answers from the same server, and the
-     * loser is at worst one client deadline stale (DEF-125). A FAILURE is not an answer, so it
-     * is written only while no newer probe has been issued; otherwise a
-     * timeout could discard a roster the server has since confirmed, undocking
-     * every panel while it is healthy (DEF-121). No request is suppressed. */
+     * `status` is the last roster the server gave, and null means it has never
+     * given one - two different facts that used to share one value. A probe
+     * that FAILS writes nothing: not answering is not an answer, and reading it
+     * as "no assistant is installed" is what emptied the sidebar on every
+     * reload whose first request landed before the server was listening
+     * (DEF-132), and on every wake whose probe fired before the network was
+     * back (DEF-119). No request is suppressed, and a failure never needs
+     * ordering against a success, because it has nothing to write. */
     const probeStatus = async (): Promise<void> => {
-      const mine = ++probeGeneration;
       try {
         status = await requestAPI<IStatusResponse>('status', serverSettings, {
           cache: 'no-store'
         });
       } catch (err) {
-        // No cadence named here: this also prints from the activation probe,
-        // and neither the interval nor the wake listeners are armed until
-        // after `await migrate()` below (DEF-122).
+        // No cadence named: this also prints from the activation probe, before
+        // the interval and the wake listeners are armed (DEF-122).
         console.warn(
-          `${LOG_PREFIX} status probe failed; panels dock again once a later probe succeeds.`,
+          `${LOG_PREFIX} status probe failed; the last known roster stands (every enabled assistant, when there is none yet) until a later probe answers.`,
           err
         );
-        if (mine === probeGeneration) {
-          status = null;
-        }
       }
     };
 
@@ -214,7 +206,10 @@ const plugin: JupyterFrontEndPlugin<void> = {
           descriptor: module.descriptor,
           hooks: module.hooks,
           rootDir: status?.root_dir ?? '',
-          deleteToTrash: status?.delete_to_trash !== false,
+          // Unknown reads as "not trash": the popup then arms its Delete
+          // button before it executes, which is the only confirmation a
+          // permanent bulk delete has (DEF-135).
+          deleteToTrash: status ? status.delete_to_trash !== false : false,
           terminalTracker,
           fileBrowser,
           colourfulTabs
@@ -258,16 +253,23 @@ const plugin: JupyterFrontEndPlugin<void> = {
         const enabled =
           setting<boolean>(`providers.${id}.enabled`, true) !== false;
         const probe = statusFor(id);
-        const available = probe ? probe.available !== false : false;
+        // Unknown is not absent. With no roster yet, an enabled assistant is
+        // docked: JupyterLab restores the sidebar tab it had open only if that
+        // tab exists when activation ends, and it waits for activation but
+        // not for a later probe - so a panel that arrives a minute late is one
+        // the layout has already given up on (DEF-132). Once a roster exists
+        // 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.
-        // A failed probe sets every provider unavailable, and 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.
+        // 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;
         if (
@@ -296,7 +298,16 @@ const plugin: JupyterFrontEndPlugin<void> = {
         }
         if (enabled && available) {
           if (live.has(id)) {
-            applySharedSettings(live.get(id)!.panel);
+            const panel = live.get(id)!.panel;
+            applySharedSettings(panel);
+            // 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(
+                roster.root_dir ?? '',
+                roster.delete_to_trash !== false
+              );
+            }
           } else {
             start(id);
           }
@@ -410,8 +421,8 @@ const plugin: JupyterFrontEndPlugin<void> = {
     }, STATUS_INTERVAL_MS);
 
     // A suspended network stack - laptop asleep, tab backgrounded - is exactly
-    // when the probe fails, and the slow cadence above would leave the sidebar
-    // panel-less for up to a minute after the machine comes back. A wake fires
+    // when the probe fails, and the slow cadence above would leave the roster
+    // stale for up to a minute after the machine comes back. A wake fires
     // both events, so it costs two probes; deliberately, because a guard that
     // let the second join the first answered the wake with a request issued
     // before it, and starved the interval above of its own tick (DEF-117).

package/style/base.css

@@ -61,7 +61,14 @@
   color: var(--jp-ui-font-color2);
 }
 
-.jp-AiAssistantsPanel-iconButton:hover {
+/* The + button while the server root is unknown (DEF-132): the glyph is an
+   icon fill, not `color`, so the UA's disabled styling never reaches it. */
+.jp-AiAssistantsPanel-iconButton:disabled {
+  cursor: default;
+  opacity: 0.4;
+}
+
+.jp-AiAssistantsPanel-iconButton:hover:not(:disabled) {
   background: var(--jp-layout-color3);
   color: var(--jp-ui-font-color1);
 }