jupyterlab_claude_code_extension 1.2.48 → 1.2.49

package/lib/colour.d.ts

@@ -0,0 +1,15 @@
+import type { ISession } from './types';
+export declare function claudeTabColourId(color: string | null | undefined): string | null;
+/** What a terminal is running, as resolved by the `terminal-cwd` probe. */
+export interface ITerminalColourInfo {
+    sessionId: string | null;
+    color: string | null;
+    cwds: string[];
+}
+/** A terminal takes its OWN conversation's colour. Never resolve colour via
+ * the project row: a row carries only the representative conversation, which
+ * flips to any newer JSONL (a daemon `--fork-session` writes one), so
+ * row-matching cleared every non-representative terminal's tint (DEF-11). cwd
+ * fallback only when the conversation is unreadable - longest path wins, so a
+ * nested project beats its parent. Null clears. */
+export declare function colourForTerminal(info: ITerminalColourInfo, sessions: ISession[]): string | null;

package/lib/colour.js

@@ -0,0 +1,40 @@
+// Claude's per-session colour (`/color`, or auto-assigned) maps to a
+// jupyterlab_colourful_tab_extension colour id. That extension owns the tab
+// CSS and colour vocabulary; we only feed it the colour. Absent or
+// unrecognised resolves to null (clear tint).
+const CLAUDE_TAB_COLOUR_ID = {
+    red: 'rose',
+    orange: 'peach',
+    yellow: 'lemon',
+    green: 'mint',
+    blue: 'sky',
+    purple: 'lavender'
+};
+export function claudeTabColourId(color) {
+    return (color && CLAUDE_TAB_COLOUR_ID[color]) || null;
+}
+/** A terminal takes its OWN conversation's colour. Never resolve colour via
+ * the project row: a row carries only the representative conversation, which
+ * flips to any newer JSONL (a daemon `--fork-session` writes one), so
+ * row-matching cleared every non-representative terminal's tint (DEF-11). cwd
+ * fallback only when the conversation is unreadable - longest path wins, so a
+ * nested project beats its parent. Null clears. */
+export function colourForTerminal(info, sessions) {
+    var _a, _b;
+    if (info.sessionId) {
+        return (_a = info.color) !== null && _a !== void 0 ? _a : 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;
+}

package/lib/widget.d.ts

@@ -98,22 +98,11 @@ export declare class ClaudeCodeSessionsWidget extends Widget {
      * 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. */
+    /** Probe a terminal: runs Claude?, which conversation, its colour, its
+     * cwd(s). Probes EVERY terminal every pass - the launch cache is not
+     * consulted, it pins the launch-time conversation and goes stale on an
+     * in-place switch. Null when 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;
     /** Find an open terminal running the wanted conversation, or null.
      *
      * Matches on the conversation id ALONE. The backend reads each terminal's

package/lib/widget.js

@@ -5,6 +5,7 @@ import { CommandRegistry } from '@lumino/commands';
 import { UUID } from '@lumino/coreutils';
 import { Menu, Widget } from '@lumino/widgets';
 import { requestAPI } from './request';
+import { claudeTabColourId, colourForTerminal } from './colour';
 import { addIcon, branchIcon, switchIcon, claudeIcon, filterIcon, refreshIcon, removeIcon, shieldIcon, starFilledIcon } from './icons';
 const POLL_INTERVAL_MS = 30000;
 // After a fork is requested, watch for its lazily-written JSONL at this fast
@@ -14,21 +15,8 @@ const BRANCH_WATCH_MAX_ATTEMPTS = 90; // ~3 minutes
 const DEFAULT_RECENT_LIMIT = 10;
 const EXPANDED_STORAGE_KEY = 'jupyterlab_claude_code_extension:expanded';
 const DEFAULT_PRESENTATION_MODE = 'name';
-// Claude's per-session colour (set by `/color`, or auto-assigned for
-// multi-session use) maps to a jupyterlab_colourful_tab_extension colour id.
-// That extension owns the tab-tint CSS and the setColour API; we only feed it
-// the colour. An absent or unrecognised colour resolves to null (clear tint).
-const CLAUDE_TAB_COLOUR_ID = {
-    red: 'rose',
-    orange: 'peach',
-    yellow: 'lemon',
-    green: 'mint',
-    blue: 'sky',
-    purple: 'lavender'
-};
-function claudeTabColourId(color) {
-    return (color && CLAUDE_TAB_COLOUR_ID[color]) || null;
-}
+// Colour resolution lives in ./colour - pure, JupyterLab-free, and therefore
+// executable under jest (the tint regressed twice behind a green suite).
 const SECTION_LABELS = {
     favourites: 'Favorites',
     recent: 'Recent',
@@ -696,21 +684,15 @@ export class ClaudeCodeSessionsWidget extends Widget {
             if (!info || !info.hasClaude || widget.isDisposed) {
                 return;
             }
-            this._applyTerminalColour(widget, this._colourForTerminal(info, sessions));
+            this._applyTerminalColour(widget, 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. */
+    /** Probe a terminal: runs Claude?, which conversation, its colour, its
+     * cwd(s). Probes EVERY terminal every pass - the launch cache is not
+     * consulted, it pins the launch-time conversation and goes stale on an
+     * in-place switch. Null when 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: [] };
-            }
-        }
+        var _a, _b, _c, _d;
         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;
@@ -720,6 +702,7 @@ export class ClaudeCodeSessionsWidget extends Widget {
             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,
+                color: (_d = data === null || data === void 0 ? void 0 : data.color) !== null && _d !== void 0 ? _d : null,
                 cwds: Array.isArray(data === null || data === void 0 ? void 0 : data.cwds) ? data.cwds : []
             };
         }
@@ -729,35 +712,6 @@ export class ClaudeCodeSessionsWidget extends Widget {
             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;
-    }
     /** Find an open terminal running the wanted conversation, or null.
      *
      * Matches on the conversation id ALONE. The backend reads each terminal's

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "jupyterlab_claude_code_extension",
-    "version": "1.2.48",
+    "version": "1.2.49",
     "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

@@ -6,6 +6,9 @@ const fs: { readFileSync: (p: string, enc: string) => string } = require('fs');
 const path: { join: (...args: string[]) => string } = require('path');
 
 import type { ISession } from '../types';
+// Executed, not grepped - src/colour.ts is JupyterLab-free by design so the
+// tint logic can actually be run under jest.
+import { claudeTabColourId, colourForTerminal } from '../colour';
 
 const session = (over: Partial<ISession> = {}): ISession => ({
   project_path: '/p',
@@ -528,6 +531,92 @@ describe('launch spinner dismiss contract', () => {
    * `claude` / `-c` is identifiable too - reuse is not limited to extension
    * launches that carry an id in argv.
    */
+  /**
+   * Tab colour (DEF-11). A terminal's tint is the colour of the conversation
+   * it RUNS, which the backend reads from that conversation's own JSONL.
+   * Resolving the tint through the project row is the bug: a row carries only
+   * the project's representative conversation, and the representative flips to
+   * any newer JSONL - a daemon `--fork-session` worker writes one - which
+   * cleared the tint of every terminal not on the current representative.
+   */
+  describe('terminal tab colour', () => {
+    // These EXECUTE the shipped code (src/colour.ts) rather than grepping its
+    // text: the tint regressed twice (DEF-10, DEF-11) behind a green suite
+    // that ran none of it.
+    const rows = [
+      session({ project_path: '/w', session_id: 'ws', color: 'blue' }),
+      session({ project_path: '/w/proj', session_id: 'rep', color: 'green' })
+    ];
+
+    it('takes the running conversation colour, not the row (DEF-11)', () => {
+      // The row's representative is 'rep'/green - a daemon fork that stole the
+      // slot. The terminal runs 'mine', whose own colour is orange. Resolving
+      // via the rows found no match and CLEARED the tint; it must not.
+      expect(
+        colourForTerminal(
+          { sessionId: 'mine', color: 'orange', cwds: ['/w/proj'] },
+          rows
+        )
+      ).toBe('orange');
+    });
+
+    it('a conversation with no colour of its own clears', () => {
+      expect(
+        colourForTerminal(
+          { sessionId: 'mine', color: null, cwds: ['/w'] },
+          rows
+        )
+      ).toBeNull();
+    });
+
+    it('falls back to cwd only when the conversation is unreadable', () => {
+      expect(
+        colourForTerminal(
+          { sessionId: null, color: null, cwds: ['/w/proj'] },
+          rows
+        )
+      ).toBe('green');
+    });
+
+    it('cwd fallback prefers the nested project over its parent', () => {
+      expect(
+        colourForTerminal(
+          { sessionId: null, color: null, cwds: ['/w/proj/deep'] },
+          rows
+        )
+      ).toBe('green');
+      expect(
+        colourForTerminal(
+          { sessionId: null, color: null, cwds: ['/w/other'] },
+          rows
+        )
+      ).toBe('blue');
+    });
+
+    it('cwd fallback does not match a sibling on a shared prefix', () => {
+      // '/w/proj-extra' must not match '/w/proj' - the boundary is a real '/'.
+      expect(
+        colourForTerminal(
+          { sessionId: null, color: null, cwds: ['/w/proj-extra'] },
+          [
+            session({
+              project_path: '/w/proj',
+              session_id: 'r',
+              color: 'green'
+            })
+          ]
+        )
+      ).toBeNull();
+    });
+
+    it('maps Claude colours to tab ids and drops unknown ones', () => {
+      expect(claudeTabColourId('orange')).toBe('peach');
+      expect(claudeTabColourId('green')).toBe('mint');
+      expect(claudeTabColourId('chartreuse')).toBeNull();
+      expect(claudeTabColourId(null)).toBeNull();
+    });
+  });
+
   describe('conversation-aware reuse + open-branch contract', () => {
     const findTerm = (widgetSrc.match(
       /private async _findTerminalForSession[\s\S]*?\n  \}/

package/src/colour.ts

@@ -0,0 +1,60 @@
+// Pure colour resolution for Claude terminal tabs. Kept free of JupyterLab
+// imports so it is directly executable under jest - the tint regressed twice
+// (DEF-10, DEF-11) behind a green suite that never ran this logic.
+import type { ISession } from './types';
+
+// Claude's per-session colour (`/color`, or auto-assigned) maps to a
+// jupyterlab_colourful_tab_extension colour id. That extension owns the tab
+// CSS and colour vocabulary; we only feed it the colour. Absent or
+// unrecognised resolves to null (clear tint).
+const CLAUDE_TAB_COLOUR_ID: Record<string, string> = {
+  red: 'rose',
+  orange: 'peach',
+  yellow: 'lemon',
+  green: 'mint',
+  blue: 'sky',
+  purple: 'lavender'
+};
+
+export function claudeTabColourId(
+  color: string | null | undefined
+): string | null {
+  return (color && CLAUDE_TAB_COLOUR_ID[color]) || null;
+}
+
+/** What a terminal is running, as resolved by the `terminal-cwd` probe. */
+export interface ITerminalColourInfo {
+  // Conversation the terminal runs, or null when it cannot be read.
+  sessionId: string | null;
+  // That conversation's OWN colour, read from its own JSONL by the backend.
+  color: string | null;
+  cwds: string[];
+}
+
+/** A terminal takes its OWN conversation's colour. Never resolve colour via
+ * the project row: a row carries only the representative conversation, which
+ * flips to any newer JSONL (a daemon `--fork-session` writes one), so
+ * row-matching cleared every non-representative terminal's tint (DEF-11). cwd
+ * fallback only when the conversation is unreadable - longest path wins, so a
+ * nested project beats its parent. Null clears. */
+export function colourForTerminal(
+  info: ITerminalColourInfo,
+  sessions: ISession[]
+): string | null {
+  if (info.sessionId) {
+    return info.color ?? 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;
+}

package/src/widget.ts

@@ -17,6 +17,7 @@ import { Menu, Widget } from '@lumino/widgets';
 import { Message } from '@lumino/messaging';
 
 import { requestAPI } from './request';
+import { claudeTabColourId, colourForTerminal } from './colour';
 import {
   addIcon,
   branchIcon,
@@ -55,22 +56,8 @@ export type PresentationMode = 'name' | 'path';
 
 const DEFAULT_PRESENTATION_MODE: PresentationMode = 'name';
 
-// Claude's per-session colour (set by `/color`, or auto-assigned for
-// multi-session use) maps to a jupyterlab_colourful_tab_extension colour id.
-// That extension owns the tab-tint CSS and the setColour API; we only feed it
-// the colour. An absent or unrecognised colour resolves to null (clear tint).
-const CLAUDE_TAB_COLOUR_ID: Record<string, string> = {
-  red: 'rose',
-  orange: 'peach',
-  yellow: 'lemon',
-  green: 'mint',
-  blue: 'sky',
-  purple: 'lavender'
-};
-
-function claudeTabColourId(color: string | null | undefined): string | null {
-  return (color && CLAUDE_TAB_COLOUR_ID[color]) || null;
-}
+// Colour resolution lives in ./colour - pure, JupyterLab-free, and therefore
+// executable under jest (the tint regressed twice behind a green suite).
 
 const SECTION_LABELS: Record<SectionKey, string> = {
   favourites: 'Favorites',
@@ -122,6 +109,10 @@ interface ITerminalCwdResponse {
   // Conversation id the running claude is resuming, or null for a fresh
   // (non-resumed) session. Lets reuse tell branches of one project apart.
   session_id?: string | null;
+  // Colour of the conversation this terminal runs, from its own JSONL.
+  // Authoritative for the tint - the row carries only the representative
+  // conversation's colour (DEF-11).
+  color?: string | null;
 }
 
 // Drop any pre-v0.6.18 localStorage entries from previous schemes - they
@@ -822,29 +813,21 @@ export class ClaudeCodeSessionsWidget extends Widget {
         if (!info || !info.hasClaude || widget.isDisposed) {
           return;
         }
-        this._applyTerminalColour(
-          widget,
-          this._colourForTerminal(info, sessions)
-        );
+        this._applyTerminalColour(widget, 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. */
+  /** Probe a terminal: runs Claude?, which conversation, its colour, its
+   * cwd(s). Probes EVERY terminal every pass - the launch cache is not
+   * consulted, it pins the launch-time conversation and goes stale on an
+   * in-place switch. Null when no session name yet, or the probe fails. */
   private async _interrogateTerminal(widget: any): Promise<{
     hasClaude: boolean;
     sessionId: string | null;
+    color: 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;
@@ -857,6 +840,7 @@ export class ClaudeCodeSessionsWidget extends Widget {
       return {
         hasClaude: !!data?.has_claude,
         sessionId: data?.session_id ?? null,
+        color: data?.color ?? null,
         cwds: Array.isArray(data?.cwds) ? data.cwds : []
       };
     } catch (_err) {
@@ -866,38 +850,6 @@ export class ClaudeCodeSessionsWidget extends Widget {
     }
   }
 
-  /** 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;
-  }
-
   /** Find an open terminal running the wanted conversation, or null.
    *
    * Matches on the conversation id ALONE. The backend reads each terminal's