jupyterlab_ai_code_assistants_extension 1.2.83 → 1.2.99

package/lib/core/panel.d.ts

@@ -45,6 +45,10 @@ export declare class AssistantSessionsPanel extends Widget {
     protected onBeforeHide(_msg: Message): void;
     protected onCloseRequest(msg: Message): void;
     private _buildShell;
+    /** Raise the click-time busy overlay. Counted, because an open and a branch
+     * can overlap; the overlay clears when the last one ends. */
+    private _beginBusy;
+    private _endBusy;
     /** Show / hide the filter input. Hiding also clears the active filter, so
      * the user never returns to an "invisible" filter narrowing the rows. */
     private _toggleFilterBar;
@@ -302,6 +306,9 @@ export declare class AssistantSessionsPanel extends Widget {
     private readonly _removingPaths;
     private _bodyEl;
     private _loadingEl;
+    private _busyEl;
+    private _busyTextEl;
+    private _busyCount;
     private _errorEl;
     private _refreshBtn;
     private _filterBtn;

package/lib/core/panel.js

@@ -112,6 +112,9 @@ export class AssistantSessionsPanel extends Widget {
         this._deleteToTrash = true;
         this._removingPaths = new Set();
         this._loadingEl = null;
+        this._busyEl = null;
+        this._busyTextEl = null;
+        this._busyCount = 0;
         this._errorEl = null;
         this._refreshBtn = null;
         this._filterBtn = null;
@@ -389,6 +392,28 @@ export class AssistantSessionsPanel extends Widget {
         loadingSpinner.className =
             'jp-aiAssistants-spinner jp-AiAssistantsPanel-loadingSpinner';
         loading.appendChild(loadingSpinner);
+        // Click-time busy overlay: raised synchronously when a row is opened or
+        // branched, before the terminal probe or the branch request, so the click
+        // never reads as ignored (DEF-PANE-318). Unlike the refresh veil it takes
+        // no pointer events and no focus: the context menu that launched a branch
+        // stays open until its command runs, and a focus change would close it.
+        const busy = document.createElement('div');
+        busy.className = 'jp-AiAssistantsPanel-busyOverlay';
+        busy.hidden = true;
+        const busySpinner = document.createElement('div');
+        busySpinner.className =
+            'jp-aiAssistants-spinner jp-AiAssistantsPanel-busySpinner';
+        busySpinner.setAttribute('aria-hidden', 'true');
+        busy.appendChild(busySpinner);
+        // The spinner is decoration; a screen-reader user hears the action
+        // instead. The region sits on the root, always rendered and outside the
+        // overlay and the aria-busy body: a live region created inside a
+        // display:none container, or one whose update lands in an aria-busy
+        // subtree, can be withheld by assistive technology.
+        const busyText = document.createElement('div');
+        busyText.className = 'jp-AiAssistantsPanel-srOnly';
+        busyText.setAttribute('role', 'status');
+        busyText.setAttribute('aria-live', 'polite');
         // Inline error strip - a failed poll reports here and keeps retrying,
         // rather than tearing the panel down or raising a modal that would also
         // interrupt the other providers' panels.
@@ -403,10 +428,42 @@ export class AssistantSessionsPanel extends Widget {
         root.appendChild(error);
         root.appendChild(body);
         root.appendChild(loading);
+        root.appendChild(busy);
+        root.appendChild(busyText);
         this._bodyEl = body;
         this._loadingEl = loading;
+        this._busyEl = busy;
+        this._busyTextEl = busyText;
         this._errorEl = error;
     }
+    /** Raise the click-time busy overlay. Counted, because an open and a branch
+     * can overlap; the overlay clears when the last one ends. */
+    _beginBusy(message) {
+        this._busyCount += 1;
+        if (this._busyEl) {
+            this._busyEl.hidden = false;
+            if (this._busyTextEl) {
+                this._busyTextEl.textContent = message;
+            }
+            // The body is what the action changes; the root stays outside the
+            // busy subtree so the live region above is not withheld.
+            if (this._bodyEl) {
+                this._bodyEl.setAttribute('aria-busy', 'true');
+            }
+        }
+    }
+    _endBusy() {
+        this._busyCount = Math.max(0, this._busyCount - 1);
+        if (this._busyCount === 0 && this._busyEl) {
+            this._busyEl.hidden = true;
+            if (this._busyTextEl) {
+                this._busyTextEl.textContent = '';
+            }
+            if (this._bodyEl) {
+                this._bodyEl.removeAttribute('aria-busy');
+            }
+        }
+    }
     /** Show / hide the filter input. Hiding also clears the active filter, so
      * the user never returns to an "invisible" filter narrowing the rows. */
     _toggleFilterBar() {
@@ -746,6 +803,9 @@ export class AssistantSessionsPanel extends Widget {
         return resolveLaunchMode(this._descriptor.launchModes, this._modes, force);
     }
     async _openSession(session, force, sessionId) {
+        // The click's own feedback, raised before the terminal walk and the
+        // launch - both can take seconds (DEF-PANE-318).
+        this._beginBusy(this._trans.__('Opening conversation'));
         try {
             await this._terminals.openSession(session, this._launchMode(force), sessionId);
             // Not awaited: the open has succeeded, and the sync is not part of it.
@@ -760,6 +820,7 @@ export class AssistantSessionsPanel extends Widget {
             }
         }
         finally {
+            this._endBusy();
             // Reuse or fresh launch, either way the picture changed. Pull fresh
             // state; a poll tick retries if this one fails.
             void this._fetch().catch(() => undefined);
@@ -985,7 +1046,16 @@ export class AssistantSessionsPanel extends Widget {
         if (!session) {
             return;
         }
-        await this._branchByServerCopy(session, undefined, force);
+        // Raised on the click: the branch POST mints the fork server-side (for
+        // Claude and Codex by running their own CLI) and can take seconds
+        // (DEF-PANE-318).
+        this._beginBusy(this._trans.__('Branching conversation'));
+        try {
+            await this._branchByServerCopy(session, undefined, force);
+        }
+        finally {
+            this._endBusy();
+        }
     }
     /** The server mints the new id and answers with it before the terminal
      * opens - `server-copy` copies the store entry, `server-native` drives the

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "jupyterlab_ai_code_assistants_extension",
-    "version": "1.2.83",
+    "version": "1.2.99",
     "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__/panel.spec.ts

@@ -455,6 +455,146 @@ describe('ACC-SESS-203 - automatic branch names', () => {
   );
 });
 
+describe('click-time busy state (DEF-PANE-318)', () => {
+  it('raises the overlay and the body busy state on the click, before the open settles', async () => {
+    const target = makePanel(DESCRIPTOR);
+    const parent = session();
+    let release!: () => void;
+    const pending = new Promise<void>(resolve => {
+      release = resolve;
+    });
+    (target as any)._terminals.openSession = jest.fn(() => pending);
+    (target as any)._fetch = jest.fn().mockResolvedValue(undefined);
+    const overlay = (): HTMLElement =>
+      target.node.querySelector('.jp-AiAssistantsPanel-busyOverlay')!;
+    const body = (): HTMLElement =>
+      target.node.querySelector('.jp-AiAssistantsPanel-body')!;
+
+    const live = target.node.querySelector(
+      '.jp-AiAssistantsPanel-srOnly'
+    ) as HTMLElement;
+    // Rendered at build, not created on demand: the region must be in the
+    // accessibility tree before the click, so its first update is announced.
+    expect(live).not.toBeNull();
+    expect(live.textContent).toBe('');
+    expect(live.getAttribute('role')).toBe('status');
+    expect(live.getAttribute('aria-live')).toBe('polite');
+
+    expect(overlay().hidden).toBe(true);
+    // Root placement is load-bearing: _render wipes the body on every fetch,
+    // including the 30 s poll, which would delete an overlay kept there.
+    expect(overlay().parentElement).toBe(target.node);
+    // The overlay takes no focus, so the context menu that launched an action
+    // cannot be closed by an element inside it taking the focus.
+    expect(overlay().hasAttribute('tabindex')).toBe(false);
+    expect(
+      overlay().querySelectorAll(
+        'a[href], button, input, select, textarea, [tabindex]'
+      )
+    ).toHaveLength(0);
+
+    const call = (target as any)._openSession(parent);
+    // The click's own task, before the open settles.
+    expect(overlay().hidden).toBe(false);
+    expect(body().getAttribute('aria-busy')).toBe('true');
+    // Outside both the hidden overlay and the busy body, so assistive
+    // technology is not told to withhold the announcement.
+    expect(live.parentElement).toBe(target.node);
+    expect(body().contains(live)).toBe(false);
+    expect(overlay().contains(live)).toBe(false);
+    expect(live.textContent).toBe('Opening conversation');
+
+    release();
+    await call;
+    expect(overlay().hidden).toBe(true);
+    expect(body().getAttribute('aria-busy')).toBeNull();
+    // Cleared, so an identical action can announce again.
+    expect(live.textContent).toBe('');
+
+    target.dispose();
+  });
+
+  it('keeps the overlay up while a second action is still running', async () => {
+    const target = makePanel(DESCRIPTOR);
+    let releaseFirst!: () => void;
+    let releaseSecond!: () => void;
+    const first = new Promise<void>(resolve => {
+      releaseFirst = resolve;
+    });
+    const second = new Promise<void>(resolve => {
+      releaseSecond = resolve;
+    });
+    const requests = [first, second];
+    (target as any)._terminals.openSession = jest.fn(() => requests.shift());
+    (target as any)._fetch = jest.fn().mockResolvedValue(undefined);
+    const overlay = (): HTMLElement =>
+      target.node.querySelector('.jp-AiAssistantsPanel-busyOverlay')!;
+    const body = (): HTMLElement =>
+      target.node.querySelector('.jp-AiAssistantsPanel-body')!;
+
+    const callOne = (target as any)._openSession(
+      session({ session_id: 'one' })
+    );
+    const callTwo = (target as any)._openSession(
+      session({ session_id: 'two' })
+    );
+    expect(overlay().hidden).toBe(false);
+
+    releaseFirst();
+    await callOne;
+    expect(overlay().hidden).toBe(false);
+    expect(body().getAttribute('aria-busy')).toBe('true');
+
+    releaseSecond();
+    await callTwo;
+    expect(overlay().hidden).toBe(true);
+    expect(body().getAttribute('aria-busy')).toBeNull();
+
+    target.dispose();
+  });
+
+  it('announces the branch action while the request is pending', async () => {
+    const target = makePanel(DESCRIPTOR);
+    const parent = session({ name: 'analysis', name_source: 'session' });
+    const launch = jest.fn().mockResolvedValue({});
+    (target as any)._terminals.launch = launch;
+    (target as any)._activeSession = parent;
+    (target as any)._fetch = jest.fn().mockResolvedValue(undefined);
+    let release!: (value: unknown) => void;
+    const pending = new Promise(resolve => {
+      release = resolve;
+    });
+    request.mockImplementation((_provider, path) =>
+      path === 'branch' ? pending : Promise.resolve({})
+    );
+    const body = (): HTMLElement =>
+      target.node.querySelector('.jp-AiAssistantsPanel-body')!;
+    const live = target.node.querySelector(
+      '.jp-AiAssistantsPanel-srOnly'
+    ) as HTMLElement;
+    let call: Promise<void> | undefined;
+    try {
+      call = (target as any)._branchSession();
+      expect(body().getAttribute('aria-busy')).toBe('true');
+      expect(live.textContent).toBe('Branching conversation');
+
+      release({ session_id: 'child' });
+      await call;
+      expect(body().getAttribute('aria-busy')).toBeNull();
+      expect(live.textContent).toBe('');
+    } finally {
+      // A failed assertion must not leave the mock unresolved for the next
+      // test; resolving twice is harmless.
+      release({ session_id: 'child' });
+      if (call) {
+        await call.catch(() => undefined);
+      }
+      target.dispose();
+      request.mockImplementation(() => Promise.resolve({}));
+    }
+  });
+});
+
 describe('a branch whose terminal launch was refused after the mint', () => {
   it('says the branch was created and still lists it when the launch is refused', async () => {
     // The DeepSeek preflight refuses the follow-up launch with a 409 whose
@@ -493,6 +633,15 @@ describe('a branch whose terminal launch was refused after the mint', () => {
     try {
       await (target as any)._branchSession();
 
+      // The refused launch still clears the click-time busy state.
+      expect(
+        (
+          target.node.querySelector(
+            '.jp-AiAssistantsPanel-busyOverlay'
+          ) as HTMLElement
+        ).hidden
+      ).toBe(true);
+
       // What the user is told: the branch was created, its terminal did not
       // open, and the refusal's own words - neither sentence that blames the
       // branch itself.
@@ -1820,6 +1969,14 @@ describe('ACC-SESS-190..192 - opening a session moves the file browser', () => {
 
     expect(opened).toHaveBeenCalledTimes(1);
     expect(moves(panel)).toEqual([]);
+    // The failed open clears the click-time busy state.
+    expect(
+      (
+        panel.node.querySelector(
+          '.jp-AiAssistantsPanel-busyOverlay'
+        ) as HTMLElement
+      ).hidden
+    ).toBe(true);
     // One notification, and it is the one the failed open raises itself.
     expect(notified()).toHaveLength(1);
     expect(notified()[0]).toContain('Could not open that conversation');

package/src/core/panel.ts

@@ -467,6 +467,29 @@ export class AssistantSessionsPanel extends Widget {
       'jp-aiAssistants-spinner jp-AiAssistantsPanel-loadingSpinner';
     loading.appendChild(loadingSpinner);
 
+    // Click-time busy overlay: raised synchronously when a row is opened or
+    // branched, before the terminal probe or the branch request, so the click
+    // never reads as ignored (DEF-PANE-318). Unlike the refresh veil it takes
+    // no pointer events and no focus: the context menu that launched a branch
+    // stays open until its command runs, and a focus change would close it.
+    const busy = document.createElement('div');
+    busy.className = 'jp-AiAssistantsPanel-busyOverlay';
+    busy.hidden = true;
+    const busySpinner = document.createElement('div');
+    busySpinner.className =
+      'jp-aiAssistants-spinner jp-AiAssistantsPanel-busySpinner';
+    busySpinner.setAttribute('aria-hidden', 'true');
+    busy.appendChild(busySpinner);
+    // The spinner is decoration; a screen-reader user hears the action
+    // instead. The region sits on the root, always rendered and outside the
+    // overlay and the aria-busy body: a live region created inside a
+    // display:none container, or one whose update lands in an aria-busy
+    // subtree, can be withheld by assistive technology.
+    const busyText = document.createElement('div');
+    busyText.className = 'jp-AiAssistantsPanel-srOnly';
+    busyText.setAttribute('role', 'status');
+    busyText.setAttribute('aria-live', 'polite');
+
     // Inline error strip - a failed poll reports here and keeps retrying,
     // rather than tearing the panel down or raising a modal that would also
     // interrupt the other providers' panels.
@@ -482,12 +505,46 @@ export class AssistantSessionsPanel extends Widget {
     root.appendChild(error);
     root.appendChild(body);
     root.appendChild(loading);
+    root.appendChild(busy);
+    root.appendChild(busyText);
 
     this._bodyEl = body;
     this._loadingEl = loading;
+    this._busyEl = busy;
+    this._busyTextEl = busyText;
     this._errorEl = error;
   }
 
+  /** Raise the click-time busy overlay. Counted, because an open and a branch
+   * can overlap; the overlay clears when the last one ends. */
+  private _beginBusy(message: string): void {
+    this._busyCount += 1;
+    if (this._busyEl) {
+      this._busyEl.hidden = false;
+      if (this._busyTextEl) {
+        this._busyTextEl.textContent = message;
+      }
+      // The body is what the action changes; the root stays outside the
+      // busy subtree so the live region above is not withheld.
+      if (this._bodyEl) {
+        this._bodyEl.setAttribute('aria-busy', 'true');
+      }
+    }
+  }
+
+  private _endBusy(): void {
+    this._busyCount = Math.max(0, this._busyCount - 1);
+    if (this._busyCount === 0 && this._busyEl) {
+      this._busyEl.hidden = true;
+      if (this._busyTextEl) {
+        this._busyTextEl.textContent = '';
+      }
+      if (this._bodyEl) {
+        this._bodyEl.removeAttribute('aria-busy');
+      }
+    }
+  }
+
   /** Show / hide the filter input. Hiding also clears the active filter, so
    * the user never returns to an "invisible" filter narrowing the rows. */
   private _toggleFilterBar(): void {
@@ -885,6 +942,9 @@ export class AssistantSessionsPanel extends Widget {
     force?: string,
     sessionId?: string
   ): Promise<void> {
+    // The click's own feedback, raised before the terminal walk and the
+    // launch - both can take seconds (DEF-PANE-318).
+    this._beginBusy(this._trans.__('Opening conversation'));
     try {
       await this._terminals.openSession(
         session,
@@ -905,6 +965,7 @@ export class AssistantSessionsPanel extends Widget {
         this._notifyLaunchError('Could not open that conversation', err);
       }
     } finally {
+      this._endBusy();
       // Reuse or fresh launch, either way the picture changed. Pull fresh
       // state; a poll tick retries if this one fails.
       void this._fetch().catch(() => undefined);
@@ -1159,7 +1220,15 @@ export class AssistantSessionsPanel extends Widget {
     if (!session) {
       return;
     }
-    await this._branchByServerCopy(session, undefined, force);
+    // Raised on the click: the branch POST mints the fork server-side (for
+    // Claude and Codex by running their own CLI) and can take seconds
+    // (DEF-PANE-318).
+    this._beginBusy(this._trans.__('Branching conversation'));
+    try {
+      await this._branchByServerCopy(session, undefined, force);
+    } finally {
+      this._endBusy();
+    }
   }
 
   /** The server mints the new id and answers with it before the terminal
@@ -2785,6 +2854,9 @@ export class AssistantSessionsPanel extends Widget {
   private readonly _removingPaths: Set<string> = new Set();
   private _bodyEl!: HTMLDivElement;
   private _loadingEl: HTMLElement | null = null;
+  private _busyEl: HTMLElement | null = null;
+  private _busyTextEl: HTMLElement | null = null;
+  private _busyCount = 0;
   private _errorEl: HTMLElement | null = null;
   private _refreshBtn: HTMLButtonElement | null = null;
   private _filterBtn: HTMLButtonElement | null = null;

package/style/base.css

@@ -559,6 +559,13 @@ body[data-jp-theme-light='true'] .jp-AiAssistantsPanel-dotHalo {
     animation: none;
     opacity: 0.5;
   }
+
+  /* The click-time busy spinner is the only thing on screen while a click is
+     being handled, so it keeps full opacity: dimmed, its brand arc measures
+     1.74:1 on the light panel, below the 3:1 minimum for a non-text cue. */
+  .jp-AiAssistantsPanel-busySpinner {
+    opacity: 1;
+  }
 }
 
 /* Full-panel veil shown only during an explicit refresh (refresh button or
@@ -581,6 +588,26 @@ body[data-jp-theme-light='true'] .jp-AiAssistantsPanel-dotHalo {
   border-width: 3px;
 }
 
+/* Click-time busy overlay (DEF-PANE-318): raised on the click, before the
+   terminal probe or the branch request. No pointer events and no focus - the
+   context menu that launched a branch stays open until its command runs, and
+   a focus change would close it. */
+.jp-AiAssistantsPanel-busyOverlay:not([hidden]) {
+  position: absolute;
+  inset: 0;
+  z-index: 9;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  pointer-events: none;
+}
+
+.jp-AiAssistantsPanel-busySpinner {
+  width: 24px;
+  height: 24px;
+  border-width: 3px;
+}
+
 .jp-AiAssistantsPanel-launchOverlay {
   display: flex;
   flex-direction: column;
@@ -740,7 +767,7 @@ body[data-jp-theme-light='true'] .jp-AiAssistantsPanel-dotHalo {
   border-radius: var(--aica-radius-lg);
 }
 
-/* Visually hidden polite live region (delete announcements). */
+/* Visually hidden polite live region (polite announcements). */
 .jp-AiAssistantsPanel-srOnly {
   position: absolute;
   width: 1px;