jupyterlab_claude_code_extension 1.0.16 → 1.0.21

package/lib/index.js

@@ -34,6 +34,10 @@ const plugin = {
                     const resolve = settings.get('resolveSessionNames')
                         .composite;
                     widget.setResolveSessionNames(resolve !== false);
+                    const limit = settings.get('recentLimit').composite;
+                    if (typeof limit === 'number') {
+                        widget.setRecentLimit(limit);
+                    }
                 };
                 apply();
                 settings.changed.connect(apply);

package/lib/types.d.ts

@@ -34,3 +34,10 @@ export interface IRemoveRequest {
 export interface IRemoveResponse {
     removed: string;
 }
+export interface ILaunchTerminalRequest {
+    project_path: string;
+    session_id: string;
+}
+export interface ILaunchTerminalResponse {
+    terminal_name: string;
+}

package/lib/widget.d.ts

@@ -7,10 +7,27 @@ export declare class ClaudeCodeSessionsWidget extends Widget {
     refresh(): void;
     /** Toggle whether explicit ``/rename`` names are honoured. */
     setResolveSessionNames(on: boolean): void;
+    /** Set how many rows the Recent section displays. */
+    setRecentLimit(n: number): void;
     protected onAfterShow(_msg: Message): void;
     protected onBeforeHide(_msg: Message): void;
     protected onCloseRequest(msg: Message): void;
     private _buildShell;
+    /** Normalise strings for filter comparison: NFD-decompose, strip combining
+     * diacritic marks, lowercase, and collapse separators (`-`, `_`, `.`, `/`,
+     * whitespace) entirely. So "foo-bar", "foo_bar", "foo bar", "Foo Bar" all
+     * compare equal as "foobar".
+     */
+    private _normalize;
+    /** Strict fuzzy match: substring on normalised strings, with up to 2%
+     * Levenshtein tolerance for queries of 6+ chars (so the 98% threshold
+     * only relaxes substring strictness when the query is long enough that
+     * 2% rounds to a nonzero edit budget - effectively substring-only for
+     * short queries).
+     */
+    private _fuzzyMatch;
+    private _levenshtein;
+    private _matchesFilter;
     private _showLoading;
     private _showError;
     private _fetch;
@@ -18,7 +35,6 @@ export declare class ClaudeCodeSessionsWidget extends Widget {
     private _remove;
     private _resumeInTerminal;
     private _doResumeInTerminal;
-    private _shellQuote;
     private _findTerminalForCwd;
     private _wireTerminalDisposal;
     /** Apply the resolve-names setting + path-segment disambiguation. */
@@ -56,5 +72,7 @@ export declare class ClaudeCodeSessionsWidget extends Widget {
     private readonly _pendingByPath;
     private readonly _rootDir;
     private _resolveNames;
+    private _recentLimit;
     private _displayNames;
+    private _filter;
 }

package/lib/widget.js

@@ -3,7 +3,7 @@ import { Menu, Widget } from '@lumino/widgets';
 import { requestAPI } from './request';
 import { claudeIcon, refreshIcon, removeIcon, starFilledIcon } from './icons';
 const POLL_INTERVAL_MS = 10000;
-const RECENT_LIMIT = 10;
+const DEFAULT_RECENT_LIMIT = 10;
 const EXPANDED_STORAGE_KEY = 'jupyterlab_claude_code_extension:expanded';
 const SECTION_LABELS = {
     favourites: 'Favourites',
@@ -65,7 +65,9 @@ export class ClaudeCodeSessionsWidget extends Widget {
         this._terminalsByPath = new Map();
         this._pendingByPath = new Map();
         this._resolveNames = true;
+        this._recentLimit = DEFAULT_RECENT_LIMIT;
         this._displayNames = new Map();
+        this._filter = '';
         this._app = app;
         this._serverSettings = app.serviceManager.serverSettings;
         this._rootDir = rootDir.replace(/\/+$/, '');
@@ -92,6 +94,15 @@ export class ClaudeCodeSessionsWidget extends Widget {
         this._resolveNames = on;
         this._render();
     }
+    /** Set how many rows the Recent section displays. */
+    setRecentLimit(n) {
+        const clamped = Math.max(1, Math.min(100, Math.floor(n)));
+        if (this._recentLimit === clamped) {
+            return;
+        }
+        this._recentLimit = clamped;
+        this._render();
+    }
     onAfterShow(_msg) {
         this.refresh();
         this._startPolling();
@@ -120,16 +131,106 @@ export class ClaudeCodeSessionsWidget extends Widget {
         refreshBtn.addEventListener('click', () => this.refresh());
         header.appendChild(refreshBtn);
         this._refreshBtn = refreshBtn;
+        const search = document.createElement('input');
+        search.type = 'search';
+        search.className = 'jp-ClaudeSessionsPanel-search';
+        search.placeholder = 'Filter sessions...';
+        search.spellcheck = false;
+        search.addEventListener('input', () => {
+            this._filter = search.value;
+            this._render();
+        });
         const body = document.createElement('div');
         body.className = 'jp-ClaudeSessionsPanel-body';
         const status = document.createElement('div');
         status.className = 'jp-ClaudeSessionsPanel-status';
         root.appendChild(header);
+        root.appendChild(search);
         root.appendChild(body);
         root.appendChild(status);
         this._bodyEl = body;
         this._statusEl = status;
     }
+    /** Normalise strings for filter comparison: NFD-decompose, strip combining
+     * diacritic marks, lowercase, and collapse separators (`-`, `_`, `.`, `/`,
+     * whitespace) entirely. So "foo-bar", "foo_bar", "foo bar", "Foo Bar" all
+     * compare equal as "foobar".
+     */
+    _normalize(s) {
+        return s
+            .normalize('NFD')
+            .replace(/[̀-ͯ]/g, '')
+            .toLowerCase()
+            .replace(/[\s\-_./]+/g, '');
+    }
+    /** Strict fuzzy match: substring on normalised strings, with up to 2%
+     * Levenshtein tolerance for queries of 6+ chars (so the 98% threshold
+     * only relaxes substring strictness when the query is long enough that
+     * 2% rounds to a nonzero edit budget - effectively substring-only for
+     * short queries).
+     */
+    _fuzzyMatch(haystack, needle) {
+        if (!needle) {
+            return true;
+        }
+        const h = this._normalize(haystack);
+        const n = this._normalize(needle);
+        if (!n) {
+            return true;
+        }
+        if (h.includes(n)) {
+            return true;
+        }
+        const tol = Math.floor(n.length * 0.02);
+        if (tol === 0) {
+            return false;
+        }
+        for (let len = n.length - tol; len <= n.length + tol; len += 1) {
+            if (len <= 0) {
+                continue;
+            }
+            for (let i = 0; i + len <= h.length; i += 1) {
+                if (this._levenshtein(h.slice(i, i + len), n) <= tol) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+    _levenshtein(a, b) {
+        const m = a.length;
+        const n = b.length;
+        if (m === 0) {
+            return n;
+        }
+        if (n === 0) {
+            return m;
+        }
+        const dp = new Array(n + 1);
+        for (let j = 0; j <= n; j += 1) {
+            dp[j] = j;
+        }
+        for (let i = 1; i <= m; i += 1) {
+            let prev = dp[0];
+            dp[0] = i;
+            for (let j = 1; j <= n; j += 1) {
+                const tmp = dp[j];
+                dp[j] =
+                    a[i - 1] === b[j - 1] ? prev : 1 + Math.min(prev, dp[j], dp[j - 1]);
+                prev = tmp;
+            }
+        }
+        return dp[n];
+    }
+    _matchesFilter(s) {
+        const q = this._filter.trim();
+        if (!q) {
+            return true;
+        }
+        return (this._fuzzyMatch(s.name, q) ||
+            this._fuzzyMatch(s.project_path, q) ||
+            this._fuzzyMatch(this._lookupName(s), q));
+    }
     _showLoading() {
         this._statusEl.textContent = this._sessions === null ? 'Loading...' : '';
     }
@@ -201,7 +302,6 @@ export class ClaudeCodeSessionsWidget extends Widget {
         return promise;
     }
     async _doResumeInTerminal(session) {
-        var _a, _b, _c;
         try {
             // 1. In-memory microcache - covers rapid-click and post-creation reuse
             // before the new widget propagates fully through the tracker. Cleared
@@ -221,49 +321,30 @@ export class ClaudeCodeSessionsWidget extends Widget {
                 this._app.shell.activateById(found.id);
                 return;
             }
-            // 3. No matching open terminal - create a new one rooted at this folder.
-            const widget = await this._app.commands.execute('terminal:create-new', { cwd: session.project_path });
+            // 3. No matching terminal - spawn a new one with `claude --resume <id>`
+            // as the pty's only process (no shell). Server-side endpoint calls
+            // terminal_manager.create(shell_command=[claude, --resume, sid], cwd=...)
+            // and returns the terminal name; we then attach JL's standard widget
+            // via terminal:open. When claude exits, the tab closes.
+            const launched = await requestAPI('launch-terminal', this._serverSettings, {
+                method: 'POST',
+                body: JSON.stringify({
+                    project_path: session.project_path,
+                    session_id: session.session_id
+                })
+            });
+            const widget = await this._app.commands.execute('terminal:open', {
+                name: launched.terminal_name
+            });
             if (widget === null || widget === void 0 ? void 0 : widget.id) {
                 this._terminalsByPath.set(session.project_path, widget);
                 this._wireTerminalDisposal(session.project_path, widget);
             }
-            const term = (_b = (_a = widget === null || widget === void 0 ? void 0 : widget.content) === null || _a === void 0 ? void 0 : _a.session) !== null && _b !== void 0 ? _b : widget === null || widget === void 0 ? void 0 : widget.session;
-            const command = `cd ${this._shellQuote(session.project_path)} && claude --resume ${session.session_id}\r`;
-            if (!term || typeof term.send !== 'function') {
-                this._statusEl.textContent = `Run in a terminal: cd ${session.project_path} && claude --resume ${session.session_id}`;
-                return;
-            }
-            // Wait for the first message from the terminal (shell prompt) before
-            // injecting input - sending too early arrives before the shell is ready.
-            let sent = false;
-            const send = () => {
-                if (sent) {
-                    return;
-                }
-                sent = true;
-                term.send({ type: 'stdin', content: [command] });
-            };
-            if ((_c = term.messageReceived) === null || _c === void 0 ? void 0 : _c.connect) {
-                const handler = () => {
-                    term.messageReceived.disconnect(handler);
-                    // Tiny additional delay so the prompt is rendered and ready for input
-                    setTimeout(send, 150);
-                };
-                term.messageReceived.connect(handler);
-                // Hard fallback: if no message arrives within 2s, send anyway
-                setTimeout(send, 2000);
-            }
-            else {
-                setTimeout(send, 600);
-            }
         }
         catch (err) {
             this._showError(err);
         }
     }
-    _shellQuote(s) {
-        return `'${s.replace(/'/g, "'\\''")}'`;
-    }
     async _findTerminalForCwd(projectPath) {
         var _a, _b;
         if (!this._terminalTracker) {
@@ -378,13 +459,15 @@ export class ClaudeCodeSessionsWidget extends Widget {
             this._bodyEl.appendChild(empty);
             return;
         }
-        // Compute disambiguated display names once per render.
+        // Compute disambiguated display names once per render (against the
+        // full set so suffixes stay stable when filtering narrows the view).
         this._displayNames = this._disambiguate(sessions);
-        const favourites = sessions.filter(s => s.favourite);
-        const recent = [...sessions]
+        const filtered = sessions.filter(s => this._matchesFilter(s));
+        const favourites = filtered.filter(s => s.favourite);
+        const recent = [...filtered]
             .sort((a, b) => b.file_mtime - a.file_mtime)
-            .slice(0, RECENT_LIMIT);
-        const all = [...sessions].sort((a, b) => this._lookupName(a).localeCompare(this._lookupName(b)));
+            .slice(0, this._recentLimit);
+        const all = [...filtered].sort((a, b) => this._lookupName(a).localeCompare(this._lookupName(b)));
         if (favourites.length > 0) {
             this._renderSection('favourites', favourites);
         }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "jupyterlab_claude_code_extension",
-    "version": "1.0.16",
+    "version": "1.0.21",
     "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",
@@ -56,7 +56,6 @@
         "watch:labextension": "jupyter labextension watch ."
     },
     "dependencies": {
-        "@jupyterlab/application": "^4.0.0",
         "@jupyterlab/apputils": "^4.0.0",
         "@jupyterlab/coreutils": "^6.0.0",
         "@jupyterlab/services": "^7.0.0",

package/src/index.ts

@@ -62,6 +62,10 @@ const plugin: JupyterFrontEndPlugin<void> = {
           const resolve = settings.get('resolveSessionNames')
             .composite as boolean;
           widget.setResolveSessionNames(resolve !== false);
+          const limit = settings.get('recentLimit').composite as number;
+          if (typeof limit === 'number') {
+            widget.setRecentLimit(limit);
+          }
         };
         apply();
         settings.changed.connect(apply);

package/src/types.ts

@@ -40,3 +40,12 @@ export interface IRemoveRequest {
 export interface IRemoveResponse {
   removed: string;
 }
+
+export interface ILaunchTerminalRequest {
+  project_path: string;
+  session_id: string;
+}
+
+export interface ILaunchTerminalResponse {
+  terminal_name: string;
+}

package/src/widget.ts

@@ -9,13 +9,14 @@ import { requestAPI } from './request';
 import { claudeIcon, refreshIcon, removeIcon, starFilledIcon } from './icons';
 import {
   IFavouriteResponse,
+  ILaunchTerminalResponse,
   IRemoveResponse,
   ISession,
   ISessionsListResponse
 } from './types';
 
 const POLL_INTERVAL_MS = 10_000;
-const RECENT_LIMIT = 10;
+const DEFAULT_RECENT_LIMIT = 10;
 const EXPANDED_STORAGE_KEY = 'jupyterlab_claude_code_extension:expanded';
 
 type SectionKey = 'favourites' | 'recent' | 'all';
@@ -114,6 +115,16 @@ export class ClaudeCodeSessionsWidget extends Widget {
     this._render();
   }
 
+  /** Set how many rows the Recent section displays. */
+  setRecentLimit(n: number): void {
+    const clamped = Math.max(1, Math.min(100, Math.floor(n)));
+    if (this._recentLimit === clamped) {
+      return;
+    }
+    this._recentLimit = clamped;
+    this._render();
+  }
+
   protected onAfterShow(_msg: Message): void {
     this.refresh();
     this._startPolling();
@@ -150,6 +161,16 @@ export class ClaudeCodeSessionsWidget extends Widget {
     header.appendChild(refreshBtn);
     this._refreshBtn = refreshBtn;
 
+    const search = document.createElement('input');
+    search.type = 'search';
+    search.className = 'jp-ClaudeSessionsPanel-search';
+    search.placeholder = 'Filter sessions...';
+    search.spellcheck = false;
+    search.addEventListener('input', () => {
+      this._filter = search.value;
+      this._render();
+    });
+
     const body = document.createElement('div');
     body.className = 'jp-ClaudeSessionsPanel-body';
 
@@ -157,6 +178,7 @@ export class ClaudeCodeSessionsWidget extends Widget {
     status.className = 'jp-ClaudeSessionsPanel-status';
 
     root.appendChild(header);
+    root.appendChild(search);
     root.appendChild(body);
     root.appendChild(status);
 
@@ -164,6 +186,92 @@ export class ClaudeCodeSessionsWidget extends Widget {
     this._statusEl = status;
   }
 
+  /** Normalise strings for filter comparison: NFD-decompose, strip combining
+   * diacritic marks, lowercase, and collapse separators (`-`, `_`, `.`, `/`,
+   * whitespace) entirely. So "foo-bar", "foo_bar", "foo bar", "Foo Bar" all
+   * compare equal as "foobar".
+   */
+  private _normalize(s: string): string {
+    return s
+      .normalize('NFD')
+      .replace(/[̀-ͯ]/g, '')
+      .toLowerCase()
+      .replace(/[\s\-_./]+/g, '');
+  }
+
+  /** Strict fuzzy match: substring on normalised strings, with up to 2%
+   * Levenshtein tolerance for queries of 6+ chars (so the 98% threshold
+   * only relaxes substring strictness when the query is long enough that
+   * 2% rounds to a nonzero edit budget - effectively substring-only for
+   * short queries).
+   */
+  private _fuzzyMatch(haystack: string, needle: string): boolean {
+    if (!needle) {
+      return true;
+    }
+    const h = this._normalize(haystack);
+    const n = this._normalize(needle);
+    if (!n) {
+      return true;
+    }
+    if (h.includes(n)) {
+      return true;
+    }
+    const tol = Math.floor(n.length * 0.02);
+    if (tol === 0) {
+      return false;
+    }
+    for (let len = n.length - tol; len <= n.length + tol; len += 1) {
+      if (len <= 0) {
+        continue;
+      }
+      for (let i = 0; i + len <= h.length; i += 1) {
+        if (this._levenshtein(h.slice(i, i + len), n) <= tol) {
+          return true;
+        }
+      }
+    }
+    return false;
+  }
+
+  private _levenshtein(a: string, b: string): number {
+    const m = a.length;
+    const n = b.length;
+    if (m === 0) {
+      return n;
+    }
+    if (n === 0) {
+      return m;
+    }
+    const dp: number[] = new Array(n + 1);
+    for (let j = 0; j <= n; j += 1) {
+      dp[j] = j;
+    }
+    for (let i = 1; i <= m; i += 1) {
+      let prev = dp[0];
+      dp[0] = i;
+      for (let j = 1; j <= n; j += 1) {
+        const tmp = dp[j];
+        dp[j] =
+          a[i - 1] === b[j - 1] ? prev : 1 + Math.min(prev, dp[j], dp[j - 1]);
+        prev = tmp;
+      }
+    }
+    return dp[n];
+  }
+
+  private _matchesFilter(s: ISession): boolean {
+    const q = this._filter.trim();
+    if (!q) {
+      return true;
+    }
+    return (
+      this._fuzzyMatch(s.name, q) ||
+      this._fuzzyMatch(s.project_path, q) ||
+      this._fuzzyMatch(this._lookupName(s), q)
+    );
+  }
+
   private _showLoading(): void {
     this._statusEl.textContent = this._sessions === null ? 'Loading...' : '';
   }
@@ -272,57 +380,34 @@ export class ClaudeCodeSessionsWidget extends Widget {
         return;
       }
 
-      // 3. No matching open terminal - create a new one rooted at this folder.
-      const widget: any = await this._app.commands.execute(
-        'terminal:create-new',
-        { cwd: session.project_path }
+      // 3. No matching terminal - spawn a new one with `claude --resume <id>`
+      // as the pty's only process (no shell). Server-side endpoint calls
+      // terminal_manager.create(shell_command=[claude, --resume, sid], cwd=...)
+      // and returns the terminal name; we then attach JL's standard widget
+      // via terminal:open. When claude exits, the tab closes.
+      const launched = await requestAPI<ILaunchTerminalResponse>(
+        'launch-terminal',
+        this._serverSettings,
+        {
+          method: 'POST',
+          body: JSON.stringify({
+            project_path: session.project_path,
+            session_id: session.session_id
+          })
+        }
       );
-
+      const widget: any = await this._app.commands.execute('terminal:open', {
+        name: launched.terminal_name
+      });
       if (widget?.id) {
         this._terminalsByPath.set(session.project_path, widget);
         this._wireTerminalDisposal(session.project_path, widget);
       }
-
-      const term = widget?.content?.session ?? widget?.session;
-      const command = `cd ${this._shellQuote(session.project_path)} && claude --resume ${session.session_id}\r`;
-
-      if (!term || typeof term.send !== 'function') {
-        this._statusEl.textContent = `Run in a terminal: cd ${session.project_path} && claude --resume ${session.session_id}`;
-        return;
-      }
-
-      // Wait for the first message from the terminal (shell prompt) before
-      // injecting input - sending too early arrives before the shell is ready.
-      let sent = false;
-      const send = () => {
-        if (sent) {
-          return;
-        }
-        sent = true;
-        term.send({ type: 'stdin', content: [command] });
-      };
-
-      if (term.messageReceived?.connect) {
-        const handler = () => {
-          term.messageReceived.disconnect(handler);
-          // Tiny additional delay so the prompt is rendered and ready for input
-          setTimeout(send, 150);
-        };
-        term.messageReceived.connect(handler);
-        // Hard fallback: if no message arrives within 2s, send anyway
-        setTimeout(send, 2000);
-      } else {
-        setTimeout(send, 600);
-      }
     } catch (err) {
       this._showError(err);
     }
   }
 
-  private _shellQuote(s: string): string {
-    return `'${s.replace(/'/g, "'\\''")}'`;
-  }
-
   private async _findTerminalForCwd(projectPath: string): Promise<any | null> {
     if (!this._terminalTracker) {
       return null;
@@ -447,14 +532,16 @@ export class ClaudeCodeSessionsWidget extends Widget {
       return;
     }
 
-    // Compute disambiguated display names once per render.
+    // Compute disambiguated display names once per render (against the
+    // full set so suffixes stay stable when filtering narrows the view).
     this._displayNames = this._disambiguate(sessions);
 
-    const favourites = sessions.filter(s => s.favourite);
-    const recent = [...sessions]
+    const filtered = sessions.filter(s => this._matchesFilter(s));
+    const favourites = filtered.filter(s => s.favourite);
+    const recent = [...filtered]
       .sort((a, b) => b.file_mtime - a.file_mtime)
-      .slice(0, RECENT_LIMIT);
-    const all = [...sessions].sort((a, b) =>
+      .slice(0, this._recentLimit);
+    const all = [...filtered].sort((a, b) =>
       this._lookupName(a).localeCompare(this._lookupName(b))
     );
 
@@ -760,5 +847,7 @@ export class ClaudeCodeSessionsWidget extends Widget {
   private readonly _pendingByPath: Map<string, Promise<void>> = new Map();
   private readonly _rootDir: string;
   private _resolveNames: boolean = true;
+  private _recentLimit: number = DEFAULT_RECENT_LIMIT;
   private _displayNames: Map<string, string> = new Map();
+  private _filter: string = '';
 }

package/style/base.css

@@ -57,6 +57,29 @@
   height: 14px;
 }
 
+.jp-ClaudeSessionsPanel-search {
+  flex: 0 0 auto;
+  margin: 4px 8px;
+  padding: 2px 6px;
+  background: var(--jp-layout-color1);
+  color: var(--jp-ui-font-color1);
+  border: 1px solid var(--jp-border-color2);
+  border-radius: 2px;
+  font-family: inherit;
+  font-size: var(--jp-ui-font-size1);
+  outline: none;
+  -webkit-appearance: none;
+  appearance: none;
+}
+
+.jp-ClaudeSessionsPanel-search:focus {
+  border-color: var(--jp-brand-color1);
+}
+
+.jp-ClaudeSessionsPanel-search::placeholder {
+  color: var(--jp-ui-font-color3);
+}
+
 .jp-ClaudeSessionsPanel-body {
   flex: 1 1 auto;
   display: flex;