jupyterlab_claude_code_extension 1.2.42 → 1.2.44

package/lib/widget.d.ts

@@ -88,13 +88,32 @@ export declare class ClaudeCodeSessionsWidget extends Widget {
      * colourful-tab extension is not installed (the token is optional). An
      * absent/unknown colour clears the tint. */
     private _applyTerminalColour;
-    /** Re-tint every tracked terminal tab from the freshest session colours.
-     * Runs after each fetch (launch refresh + the 30s poll), so a `/color`
-     * change shows on the next tick. Matches on project AND conversation so a
-     * tab only takes the colour of the exact session it runs; a terminal
-     * running a branch other than the project's representative row stays
-     * untinted rather than borrowing a sibling's colour. */
+    /** Re-tint EVERY open Claude terminal tab from the freshest session colours,
+     * whether the plugin launched it or the user opened it themselves. Walks
+     * JupyterLab's terminal tracker (the registry of all open terminals) rather
+     * than only the plugin's own launch cache, and re-resolves each terminal's
+     * Claude conversation on every pass via the ``terminal-cwd`` probe - so a tab
+     * whose terminal has since started (or switched) a Claude conversation is
+     * re-tinted correctly rather than pinned to a stale identity. The probe is a
+     * few /proc reads per terminal; runs after each fetch (launch refresh + the
+     * 30s poll), which is already gated to skip while a context menu is open. */
     private _reconcileTerminalColours;
+    /** Resolve a terminal's Claude identity: does it run Claude, which
+     * conversation id, and its cwd(s). Panel-launched terminals are already known
+     * (their conversation was confirmed at launch), so those skip the backend
+     * probe; every other terminal is probed once via ``terminal-cwd``. Returns
+     * ``null`` when the terminal has no session name yet or the probe fails. */
+    private _interrogateTerminal;
+    /** Pick a terminal's tab colour from the session list. When the terminal runs
+     * a known conversation (its argv carried a ``--resume`` / ``--session-id``),
+     * match on that id ONLY: it takes the colour of the exact conversation, or -
+     * when that conversation is not the project's representative row - clears,
+     * rather than borrowing a sibling branch's colour. The cwd fallback is used
+     * ONLY for a terminal with no conversation id (a bare ``claude`` / ``-c``),
+     * matching the project the terminal is cwd'd in and preferring the longest
+     * matching path so a nested project wins over its parent. Returns null (clear)
+     * when no row matches or the matched row has no colour. */
+    private _colourForTerminal;
     private _findTerminalForCwd;
     private _showCloseExistingDialog;
     /** Show a modal with a spinner while the terminal is being launched. The

package/lib/widget.js

@@ -353,7 +353,8 @@ export class ClaudeCodeSessionsWidget extends Widget {
         const data = await requestAPI('sessions', this._serverSettings, { cache: 'no-store' });
         this._sessions = (_a = data.sessions) !== null && _a !== void 0 ? _a : [];
         this._render();
-        this._reconcileTerminalColours();
+        // Best-effort tab tinting; never let a colour failure break the fetch.
+        this._reconcileTerminalColours().catch(() => undefined);
     }
     async _toggleFavourite(session) {
         const next = !session.favourite;
@@ -669,23 +670,93 @@ export class ClaudeCodeSessionsWidget extends Widget {
         }
         this._colourfulTabs.setColour(widget, claudeTabColourId(color));
     }
-    /** Re-tint every tracked terminal tab from the freshest session colours.
-     * Runs after each fetch (launch refresh + the 30s poll), so a `/color`
-     * change shows on the next tick. Matches on project AND conversation so a
-     * tab only takes the colour of the exact session it runs; a terminal
-     * running a branch other than the project's representative row stays
-     * untinted rather than borrowing a sibling's colour. */
-    _reconcileTerminalColours() {
+    /** Re-tint EVERY open Claude terminal tab from the freshest session colours,
+     * whether the plugin launched it or the user opened it themselves. Walks
+     * JupyterLab's terminal tracker (the registry of all open terminals) rather
+     * than only the plugin's own launch cache, and re-resolves each terminal's
+     * Claude conversation on every pass via the ``terminal-cwd`` probe - so a tab
+     * whose terminal has since started (or switched) a Claude conversation is
+     * re-tinted correctly rather than pinned to a stale identity. The probe is a
+     * few /proc reads per terminal; runs after each fetch (launch refresh + the
+     * 30s poll), which is already gated to skip while a context menu is open. */
+    async _reconcileTerminalColours() {
         var _a;
+        if (!this._colourfulTabs || !this._terminalTracker) {
+            return;
+        }
         const sessions = (_a = this._sessions) !== null && _a !== void 0 ? _a : [];
-        this._terminalsByPath.forEach((entry, projectPath) => {
-            var _a;
-            if (!entry.widget || entry.widget.isDisposed) {
-                return;
+        const widgets = [];
+        this._terminalTracker.forEach((widget) => {
+            if (widget && !widget.isDisposed) {
+                widgets.push(widget);
             }
-            const match = sessions.find(s => s.project_path === projectPath && s.session_id === entry.sessionId);
-            this._applyTerminalColour(entry.widget, (_a = match === null || match === void 0 ? void 0 : match.color) !== null && _a !== void 0 ? _a : null);
         });
+        await Promise.all(widgets.map(async (widget) => {
+            const info = await this._interrogateTerminal(widget);
+            if (!info || !info.hasClaude || widget.isDisposed) {
+                return;
+            }
+            this._applyTerminalColour(widget, this._colourForTerminal(info, sessions));
+        }));
+    }
+    /** Resolve a terminal's Claude identity: does it run Claude, which
+     * conversation id, and its cwd(s). Panel-launched terminals are already known
+     * (their conversation was confirmed at launch), so those skip the backend
+     * probe; every other terminal is probed once via ``terminal-cwd``. Returns
+     * ``null`` when the terminal has no session name yet or the probe fails. */
+    async _interrogateTerminal(widget) {
+        var _a, _b, _c;
+        for (const entry of this._terminalsByPath.values()) {
+            if (entry.widget === widget && entry.sessionId) {
+                return { hasClaude: true, sessionId: entry.sessionId, cwds: [] };
+            }
+        }
+        const sessName = (_b = (_a = widget === null || widget === void 0 ? void 0 : widget.content) === null || _a === void 0 ? void 0 : _a.session) === null || _b === void 0 ? void 0 : _b.name;
+        if (typeof sessName !== 'string' || !sessName) {
+            return null;
+        }
+        try {
+            const data = await requestAPI(`terminal-cwd/${encodeURIComponent(sessName)}`, this._serverSettings);
+            return {
+                hasClaude: !!(data === null || data === void 0 ? void 0 : data.has_claude),
+                sessionId: (_c = data === null || data === void 0 ? void 0 : data.session_id) !== null && _c !== void 0 ? _c : null,
+                cwds: Array.isArray(data === null || data === void 0 ? void 0 : data.cwds) ? data.cwds : []
+            };
+        }
+        catch (_err) {
+            // Backend may 404 for a terminal that vanished between enumeration and
+            // probe - treat as unresolved and retry on the next poll.
+            return null;
+        }
+    }
+    /** Pick a terminal's tab colour from the session list. When the terminal runs
+     * a known conversation (its argv carried a ``--resume`` / ``--session-id``),
+     * match on that id ONLY: it takes the colour of the exact conversation, or -
+     * when that conversation is not the project's representative row - clears,
+     * rather than borrowing a sibling branch's colour. The cwd fallback is used
+     * ONLY for a terminal with no conversation id (a bare ``claude`` / ``-c``),
+     * matching the project the terminal is cwd'd in and preferring the longest
+     * matching path so a nested project wins over its parent. Returns null (clear)
+     * when no row matches or the matched row has no colour. */
+    _colourForTerminal(info, sessions) {
+        var _a, _b;
+        if (info.sessionId) {
+            const bySession = sessions.find(s => s.session_id === info.sessionId);
+            return bySession ? ((_a = bySession.color) !== null && _a !== void 0 ? _a : null) : null;
+        }
+        let best;
+        let bestLen = -1;
+        for (const raw of info.cwds) {
+            const cwd = raw.replace(/\/+$/, '');
+            for (const s of sessions) {
+                const p = s.project_path.replace(/\/+$/, '');
+                if ((cwd === p || cwd.startsWith(p + '/')) && p.length > bestLen) {
+                    best = s;
+                    bestLen = p.length;
+                }
+            }
+        }
+        return best ? ((_b = best.color) !== null && _b !== void 0 ? _b : null) : null;
     }
     async _findTerminalForCwd(projectPath, wantedSessionId) {
         var _a, _b, _c;
@@ -767,9 +838,11 @@ export class ClaudeCodeSessionsWidget extends Widget {
             body,
             buttons: []
         });
-        // launch() returns a Promise we don't await - we resolve programmatically
-        // when the spawn completes (or errors).
-        void dialog.launch();
+        // launch() returns a Promise we don't await - the caller dismisses this
+        // dialog with .dispose() when the spawn completes. Disposing an open Lumino
+        // dialog rejects that promise with `undefined`, so catch it here to keep a
+        // benign teardown from surfacing as an unhandled promise rejection.
+        dialog.launch().catch(() => undefined);
         return dialog;
     }
     _wireTerminalDisposal(projectPath, widget) {
@@ -1171,7 +1244,9 @@ export class ClaudeCodeSessionsWidget extends Widget {
                     Notification.warning('Folder is outside the JupyterLab root - cannot open a terminal there.', { autoClose: 4000 });
                     return;
                 }
-                void this._app.commands.execute('terminal:create-new', { cwd: rel });
+                this._app.commands
+                    .execute('terminal:create-new', { cwd: rel })
+                    .catch(err => this._showError(err));
             }
         });
         this._commands.addCommand('claude-code-sessions:show-in-filebrowser', {
@@ -1190,9 +1265,9 @@ export class ClaudeCodeSessionsWidget extends Widget {
                 }
                 // JL's built-in command navigates the default file browser to the
                 // path and reveals the browser panel.
-                void this._app.commands.execute('filebrowser:go-to-path', {
-                    path: rel
-                });
+                this._app.commands
+                    .execute('filebrowser:go-to-path', { path: rel })
+                    .catch(err => this._showError(err));
             }
         });
         this._commands.addCommand('claude-code-sessions:copy-path', {
@@ -1760,7 +1835,9 @@ export class ClaudeCodeSessionsWidget extends Widget {
         });
         render();
         updateControls();
-        void dialog.launch();
+        // dialog.dispose() (on open/switch) rejects this promise with `undefined`;
+        // catch it so the teardown never surfaces as an unhandled promise rejection.
+        dialog.launch().catch(() => undefined);
         search.focus();
     }
     /** Delete the given branch sessions of the active row's project.
@@ -1890,7 +1967,9 @@ export class ClaudeCodeSessionsWidget extends Widget {
                 : `Branch switch failed: ${err}`, { autoClose: 4000 });
         }
         finally {
-            await this._fetch();
+            // Best-effort refresh - never let a transient fetch failure reject this
+            // fire-and-forget switch (its callers do not await it).
+            await this._fetch().catch(() => undefined);
         }
     }
     /** Open a specific conversation branch in its own terminal.

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "jupyterlab_claude_code_extension",
-    "version": "1.2.42",
+    "version": "1.2.44",
     "description": "Browse, resume, and manage your Claude Code CLI sessions from a JupyterLab side panel. One click reactivates the right terminal - no duplicate tabs, live remote-control indicator, and favourites for the projects you keep coming back to.",
     "keywords": [
         "jupyter",

package/src/__tests__/jupyterlab_claude_code_extension.spec.ts

@@ -23,6 +23,7 @@ const session = (over: Partial<ISession> = {}): ISession => ({
   remote_control: false,
   favourite: false,
   extra_sessions: 0,
+  color: null,
   ...over
 });
 

package/src/widget.ts

@@ -428,7 +428,8 @@ export class ClaudeCodeSessionsWidget extends Widget {
     );
     this._sessions = data.sessions ?? [];
     this._render();
-    this._reconcileTerminalColours();
+    // Best-effort tab tinting; never let a colour failure break the fetch.
+    this._reconcileTerminalColours().catch(() => undefined);
   }
 
   private async _toggleFavourite(session: ISession): Promise<void> {
@@ -798,23 +799,106 @@ export class ClaudeCodeSessionsWidget extends Widget {
     this._colourfulTabs.setColour(widget, claudeTabColourId(color));
   }
 
-  /** Re-tint every tracked terminal tab from the freshest session colours.
-   * Runs after each fetch (launch refresh + the 30s poll), so a `/color`
-   * change shows on the next tick. Matches on project AND conversation so a
-   * tab only takes the colour of the exact session it runs; a terminal
-   * running a branch other than the project's representative row stays
-   * untinted rather than borrowing a sibling's colour. */
-  private _reconcileTerminalColours(): void {
+  /** Re-tint EVERY open Claude terminal tab from the freshest session colours,
+   * whether the plugin launched it or the user opened it themselves. Walks
+   * JupyterLab's terminal tracker (the registry of all open terminals) rather
+   * than only the plugin's own launch cache, and re-resolves each terminal's
+   * Claude conversation on every pass via the ``terminal-cwd`` probe - so a tab
+   * whose terminal has since started (or switched) a Claude conversation is
+   * re-tinted correctly rather than pinned to a stale identity. The probe is a
+   * few /proc reads per terminal; runs after each fetch (launch refresh + the
+   * 30s poll), which is already gated to skip while a context menu is open. */
+  private async _reconcileTerminalColours(): Promise<void> {
+    if (!this._colourfulTabs || !this._terminalTracker) {
+      return;
+    }
     const sessions = this._sessions ?? [];
-    this._terminalsByPath.forEach((entry, projectPath) => {
-      if (!entry.widget || entry.widget.isDisposed) {
-        return;
+    const widgets: any[] = [];
+    this._terminalTracker.forEach((widget: any) => {
+      if (widget && !widget.isDisposed) {
+        widgets.push(widget);
       }
-      const match = sessions.find(
-        s => s.project_path === projectPath && s.session_id === entry.sessionId
-      );
-      this._applyTerminalColour(entry.widget, match?.color ?? null);
     });
+    await Promise.all(
+      widgets.map(async widget => {
+        const info = await this._interrogateTerminal(widget);
+        if (!info || !info.hasClaude || widget.isDisposed) {
+          return;
+        }
+        this._applyTerminalColour(
+          widget,
+          this._colourForTerminal(info, sessions)
+        );
+      })
+    );
+  }
+
+  /** Resolve a terminal's Claude identity: does it run Claude, which
+   * conversation id, and its cwd(s). Panel-launched terminals are already known
+   * (their conversation was confirmed at launch), so those skip the backend
+   * probe; every other terminal is probed once via ``terminal-cwd``. Returns
+   * ``null`` when the terminal has no session name yet or the probe fails. */
+  private async _interrogateTerminal(widget: any): Promise<{
+    hasClaude: boolean;
+    sessionId: string | null;
+    cwds: string[];
+  } | null> {
+    for (const entry of this._terminalsByPath.values()) {
+      if (entry.widget === widget && entry.sessionId) {
+        return { hasClaude: true, sessionId: entry.sessionId, cwds: [] };
+      }
+    }
+    const sessName: string | undefined = widget?.content?.session?.name;
+    if (typeof sessName !== 'string' || !sessName) {
+      return null;
+    }
+    try {
+      const data = await requestAPI<ITerminalCwdResponse>(
+        `terminal-cwd/${encodeURIComponent(sessName)}`,
+        this._serverSettings
+      );
+      return {
+        hasClaude: !!data?.has_claude,
+        sessionId: data?.session_id ?? null,
+        cwds: Array.isArray(data?.cwds) ? data.cwds : []
+      };
+    } catch (_err) {
+      // Backend may 404 for a terminal that vanished between enumeration and
+      // probe - treat as unresolved and retry on the next poll.
+      return null;
+    }
+  }
+
+  /** Pick a terminal's tab colour from the session list. When the terminal runs
+   * a known conversation (its argv carried a ``--resume`` / ``--session-id``),
+   * match on that id ONLY: it takes the colour of the exact conversation, or -
+   * when that conversation is not the project's representative row - clears,
+   * rather than borrowing a sibling branch's colour. The cwd fallback is used
+   * ONLY for a terminal with no conversation id (a bare ``claude`` / ``-c``),
+   * matching the project the terminal is cwd'd in and preferring the longest
+   * matching path so a nested project wins over its parent. Returns null (clear)
+   * when no row matches or the matched row has no colour. */
+  private _colourForTerminal(
+    info: { sessionId: string | null; cwds: string[] },
+    sessions: ISession[]
+  ): string | null {
+    if (info.sessionId) {
+      const bySession = sessions.find(s => s.session_id === info.sessionId);
+      return bySession ? (bySession.color ?? null) : null;
+    }
+    let best: ISession | undefined;
+    let bestLen = -1;
+    for (const raw of info.cwds) {
+      const cwd = raw.replace(/\/+$/, '');
+      for (const s of sessions) {
+        const p = s.project_path.replace(/\/+$/, '');
+        if ((cwd === p || cwd.startsWith(p + '/')) && p.length > bestLen) {
+          best = s;
+          bestLen = p.length;
+        }
+      }
+    }
+    return best ? (best.color ?? null) : null;
   }
 
   private async _findTerminalForCwd(
@@ -906,9 +990,11 @@ export class ClaudeCodeSessionsWidget extends Widget {
       body,
       buttons: []
     });
-    // launch() returns a Promise we don't await - we resolve programmatically
-    // when the spawn completes (or errors).
-    void dialog.launch();
+    // launch() returns a Promise we don't await - the caller dismisses this
+    // dialog with .dispose() when the spawn completes. Disposing an open Lumino
+    // dialog rejects that promise with `undefined`, so catch it here to keep a
+    // benign teardown from surfacing as an unhandled promise rejection.
+    dialog.launch().catch(() => undefined);
     return dialog;
   }
 
@@ -1356,7 +1442,9 @@ export class ClaudeCodeSessionsWidget extends Widget {
           );
           return;
         }
-        void this._app.commands.execute('terminal:create-new', { cwd: rel });
+        this._app.commands
+          .execute('terminal:create-new', { cwd: rel })
+          .catch(err => this._showError(err));
       }
     });
 
@@ -1379,9 +1467,9 @@ export class ClaudeCodeSessionsWidget extends Widget {
         }
         // JL's built-in command navigates the default file browser to the
         // path and reveals the browser panel.
-        void this._app.commands.execute('filebrowser:go-to-path', {
-          path: rel
-        });
+        this._app.commands
+          .execute('filebrowser:go-to-path', { path: rel })
+          .catch(err => this._showError(err));
       }
     });
 
@@ -2009,7 +2097,9 @@ export class ClaudeCodeSessionsWidget extends Widget {
     render();
     updateControls();
 
-    void dialog.launch();
+    // dialog.dispose() (on open/switch) rejects this promise with `undefined`;
+    // catch it so the teardown never surfaces as an unhandled promise rejection.
+    dialog.launch().catch(() => undefined);
     search.focus();
   }
 
@@ -2156,7 +2246,9 @@ export class ClaudeCodeSessionsWidget extends Widget {
         { autoClose: 4000 }
       );
     } finally {
-      await this._fetch();
+      // Best-effort refresh - never let a transient fetch failure reject this
+      // fire-and-forget switch (its callers do not await it).
+      await this._fetch().catch(() => undefined);
     }
   }