jupyterlab_claude_code_extension 1.2.42 → 1.2.43

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;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "jupyterlab_claude_code_extension",
-    "version": "1.2.42",
+    "version": "1.2.43",
     "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(