xtralab 0.14.0 → 0.15.0

package/lib/sidebar/index.js

@@ -3,6 +3,27 @@ import { ISettingRegistry } from '@jupyterlab/settingregistry';
 import { ITranslator, nullTranslator } from '@jupyterlab/translation';
 const PLUGIN_ID = 'xtralab:sidebar';
 const TARGETS = [
+    {
+        id: 'xtralab-running-terminals',
+        rank: 1,
+        settingKey: 'showTerminals',
+        command: 'xtralab:toggle-terminals',
+        label: trans => trans.__('Terminals')
+    },
+    {
+        id: 'xtralab:file-browser',
+        rank: 2,
+        settingKey: 'showFileBrowser',
+        command: 'xtralab:toggle-file-browser',
+        label: trans => trans.__('File Browser')
+    },
+    {
+        id: 'jp-git-sessions',
+        rank: 200,
+        settingKey: 'showGitPanel',
+        command: 'xtralab:toggle-git-panel',
+        label: trans => trans.__('Git')
+    },
     {
         id: 'filebrowser',
         rank: 100,
@@ -16,55 +37,61 @@ const TARGETS = [
         settingKey: 'showRunningSessions',
         command: 'xtralab:toggle-running-sessions',
         label: trans => trans.__('Running Terminals and Kernels')
+    },
+    {
+        id: 'jp-search-replace',
+        rank: 900,
+        settingKey: 'showSearchReplace',
+        command: 'xtralab:toggle-search-replace',
+        label: trans => trans.__('Search and Replace')
     }
 ];
 /**
- * Lets the user toggle individual left-sidebar tabs from
- * View > Appearance > Left Sidebar. Removing a widget from a `LabShell`
- * side area is done by setting `widget.parent = null`: the StackedPanel
- * emits `widgetRemoved`, which the SideBarHandler responds to by removing
- * the matching tab. The widget instance is preserved, so we can re-add it
- * later via `labShell.add` with its original rank.
- *
- * The menu placement is contributed declaratively in
- * `schema/sidebar.json`, so this plugin only registers commands and
- * applies state — it does not touch `IMainMenu` directly.
- *
- * The preference is persisted to `xtralab:sidebar` settings so the choice
- * survives reloads.
+ * Toggles individual sidebar tabs from View > Appearance > Sidebars,
+ * whichever side a tab currently lives on. Hiding detaches the widget
+ * (`widget.parent = null`) while keeping the instance for a later
+ * re-add; the preference persists in this plugin's settings. Which side
+ * a hidden tab came from is only tracked in-memory, so after a reload a
+ * re-shown tab lands on the left. The menu placement is contributed
+ * declaratively in `schema/sidebar.json`.
  */
 const plugin = {
     id: PLUGIN_ID,
-    description: 'Toggle visibility of selected sidebar tabs (default file browser, running sessions) from the View menu.',
+    description: 'Toggle visibility of individual sidebar tabs from the View menu.',
     autoStart: true,
     requires: [ILabShell],
     optional: [ISettingRegistry, ITranslator],
     activate: async (app, labShell, settingRegistry, translator) => {
         const trans = (translator !== null && translator !== void 0 ? translator : nullTranslator).load('jupyterlab');
         const { commands } = app;
-        // Cache widget instances so we can re-add them after `widget.parent =
-        // null` has detached them from the sidebar. The widget is no longer
-        // reachable through `labShell.widgets('left')` once removed, so a
-        // missing cache entry would leave us unable to bring the tab back.
+        // Detached widgets are unreachable via `labShell.widgets(...)`; keep
+        // instances here so hidden tabs can be re-added.
         const widgetCache = new Map();
-        const findInSidebar = (id) => {
-            for (const w of labShell.widgets('left')) {
-                if (w.id === id) {
-                    return w;
+        // Side each hidden widget was removed from, so re-showing restores it
+        // there.
+        const hiddenFrom = new Map();
+        const findInSidebars = (id) => {
+            for (const area of ['left', 'right']) {
+                for (const widget of labShell.widgets(area)) {
+                    if (widget.id === id) {
+                        return { widget, area };
+                    }
                 }
             }
             return null;
         };
+        const locate = (id) => { var _a, _b; return (_b = (_a = findInSidebars(id)) === null || _a === void 0 ? void 0 : _a.area) !== null && _b !== void 0 ? _b : null; };
         const captureWidget = (id) => {
+            var _a;
             const cached = widgetCache.get(id);
             if (cached && !cached.isDisposed) {
                 return cached;
             }
-            const found = findInSidebar(id);
+            const found = findInSidebars(id);
             if (found) {
-                widgetCache.set(id, found);
+                widgetCache.set(id, found.widget);
             }
-            return found;
+            return (_a = found === null || found === void 0 ? void 0 : found.widget) !== null && _a !== void 0 ? _a : null;
         };
         let settings = null;
         const readPreference = (target) => {
@@ -75,22 +102,28 @@ const plugin = {
             return typeof value === 'boolean' ? value : true;
         };
         const apply = (target) => {
+            var _a;
             const widget = captureWidget(target.id);
             if (!widget) {
-                // The upstream widget hasn't been added yet (or the extension is
-                // disabled). Nothing to do — the next time `apply` runs and finds
-                // it, the preference will take effect.
+                // Not seen yet (extension disabled or not added) — nothing to do.
+                return;
+            }
+            const area = locate(target.id);
+            if (!area && widget.parent !== null) {
+                // Attached outside the sidebars — leave it alone.
                 return;
             }
-            const present = findInSidebar(target.id) !== null;
             const wantPresent = readPreference(target);
-            if (wantPresent && !present) {
-                labShell.add(widget, 'left', { rank: target.rank });
+            if (wantPresent && !area) {
+                labShell.add(widget, (_a = hiddenFrom.get(target.id)) !== null && _a !== void 0 ? _a : 'left', {
+                    rank: target.rank
+                });
+                hiddenFrom.delete(target.id);
             }
-            else if (!wantPresent && present) {
-                // Setting `parent = null` triggers SideBarHandler's
-                // `_onWidgetRemoved`, which strips the tab while leaving the
-                // widget instance alive for a later re-add.
+            else if (!wantPresent && area) {
+                hiddenFrom.set(target.id, area);
+                // Detaching makes the SideBarHandler remove the tab while the
+                // widget instance stays alive for a later re-add.
                 widget.parent = null;
             }
         };
@@ -103,23 +136,27 @@ const plugin = {
             commands.addCommand(target.command, {
                 label: target.label(trans),
                 isToggled: () => readPreference(target),
+                isVisible: () => {
+                    // List only tabs this plugin can manage: in a sidebar, or
+                    // hidden by this plugin (`parent === null`).
+                    const widget = captureWidget(target.id);
+                    return (widget !== null &&
+                        (widget.parent === null || locate(target.id) !== null));
+                },
                 execute: async () => {
                     const next = !readPreference(target);
                     if (settings) {
                         try {
                             await settings.set(target.settingKey, next);
-                            // `settings.changed` will fire and drive `apply` + the
-                            // command-state refresh. Returning here keeps the toggle's
-                            // single source of truth in the settings registry.
+                            // `settings.changed` drives `apply` and the state refresh.
                             return;
                         }
                         catch (reason) {
                             console.error(`xtralab: failed to persist ${target.settingKey}`, reason);
                         }
                     }
-                    // No settings registry available (or the write failed): fall
-                    // back to applying the change in-memory so the toggle still
-                    // works for the current session.
+                    // No settings registry (or the write failed): apply in-memory
+                    // for the current session only.
                     apply(target);
                     commands.notifyCommandChanged(target.command);
                 }
@@ -140,11 +177,8 @@ const plugin = {
             }
         }
         void app.restored.then(() => {
-            // Capture references first so a hidden-on-startup widget is still
-            // recoverable later. `apply` would also do the lookup, but only on
-            // the targets that need to stay visible — by capturing every target
-            // here we keep the cache populated for both directions of the
-            // toggle.
+            // Capture every widget before applying, so tabs hidden on startup
+            // stay recoverable.
             for (const target of TARGETS) {
                 captureWidget(target.id);
             }

package/lib/terminals/index.d.ts

@@ -17,9 +17,11 @@ import { IAgentTerminals } from './tokens';
  *
  * Clicking a row activates the existing tab if one is open, or reopens
  * the session in a fresh terminal widget (`terminal:open`). The inline
- * `×` button shuts the session down on the server. The header carries a
- * `+` button and a stop button (the latter shuts every session down at
- * once, after a confirmation).
+ * `×` button shuts the session down on the server. The Terminals
+ * section's title toolbar carries a `+` button and a stop button (the
+ * latter shuts every session down at once, after a confirmation).
+ *
+ * The list is one movable section, and other panels' sections can move in.
  *
  * The `+` button drops down a menu — built from the launcher's shared
  * `IAgentRegistry` — listing each available agent (Claude, Codex, …)

package/lib/terminals/index.js

@@ -1,5 +1,5 @@
 import { ILayoutRestorer } from '@jupyterlab/application';
-import { Dialog, showDialog } from '@jupyterlab/apputils';
+import { Dialog, IMovableSectionRegistry, showDialog } from '@jupyterlab/apputils';
 import { ISettingRegistry } from '@jupyterlab/settingregistry';
 import { ITerminalTracker } from '@jupyterlab/terminal';
 import { ITranslator, nullTranslator } from '@jupyterlab/translation';
@@ -29,9 +29,11 @@ const PLUGIN_ID = 'xtralab:terminals';
  *
  * Clicking a row activates the existing tab if one is open, or reopens
  * the session in a fresh terminal widget (`terminal:open`). The inline
- * `×` button shuts the session down on the server. The header carries a
- * `+` button and a stop button (the latter shuts every session down at
- * once, after a confirmation).
+ * `×` button shuts the session down on the server. The Terminals
+ * section's title toolbar carries a `+` button and a stop button (the
+ * latter shuts every session down at once, after a confirmation).
+ *
+ * The list is one movable section, and other panels' sections can move in.
  *
  * The `+` button drops down a menu — built from the launcher's shared
  * `IAgentRegistry` — listing each available agent (Claude, Codex, …)
@@ -57,9 +59,10 @@ const plugin = {
         IAgentRegistry,
         IEditorRegistry,
         IAgentSessions,
-        ISettingRegistry
+        ISettingRegistry,
+        IMovableSectionRegistry
     ],
-    activate: (app, tracker, restorer, translator, agentRegistry, editorRegistry, agentSessions, settingRegistry) => {
+    activate: (app, tracker, restorer, translator, agentRegistry, editorRegistry, agentSessions, settingRegistry, movableSections) => {
         const trans = (translator !== null && translator !== void 0 ? translator : nullTranslator).load('jupyterlab');
         // Resolve a running agent/editor identifier to an icon: the matching
         // agent's logo, the matching editor's logo (Neovim/Vim), or the plain
@@ -224,6 +227,14 @@ const plugin = {
         if (restorer) {
             restorer.add(panel, panel.id);
         }
+        void app.restored.then(() => {
+            panel.expandOwnSection();
+        });
+        if (movableSections) {
+            movableSections.registerSource(PLUGIN_ID, trans.__('Terminals'), panel);
+            movableSections.registerTarget(PLUGIN_ID, trans.__('Terminals'), panel);
+            panel.announceSections();
+        }
         // The latest-activity line under each agent row is on by default; honour
         // the `showAgentActivity` setting so it can be turned off. Read on load and
         // re-applied on every change.

package/lib/terminals/widget.d.ts

@@ -1,35 +1,39 @@
+import { IMovableSectionDestination, IMovableSectionSource, ISectionEntry } from '@jupyterlab/apputils';
 import { type TranslationBundle } from '@jupyterlab/translation';
-import { LabIcon, ReactWidget } from '@jupyterlab/ui-components';
-import * as React from 'react';
+import { LabIcon, SidePanel } from '@jupyterlab/ui-components';
+import { ISignal } from '@lumino/signaling';
+import { AccordionPanel, Widget } from '@lumino/widgets';
 import { SessionRegistry } from './model';
 /**
- * Left-sidebar panel listing every running terminal session. It is the
- * sidebar counterpart of the launcher's terminal tiles: where the
- * launcher *starts* sessions, this panel surfaces the ones already
- * running so the user can jump back to a backgrounded agent — including
- * sessions whose tab has been closed but which are still alive on the
- * server. Each row is labelled with the session's title and, for a session
- * running a coding agent, a smaller line below it showing the agent's latest
- * line of output (from {@link SessionRegistry.activityFor}).
- *
- * Backed by {@link SessionRegistry}: a `UseSignal` re-renders the list
- * whenever the registry emits `stateChanged`, so it tracks
- * `runningChanged` and the agent-title cache without any local state.
- * Click behavior (activate vs. reopen, shutdown, new terminal) is
- * delegated to plugin-supplied callbacks so the widget never imports
- * `app`.
+ * Left-sidebar panel listing every running terminal session, including the
+ * sessions whose tab is closed but which are still alive on the server. The
+ * list is a single movable "Terminals" section.
  */
-export declare class RunningTerminals extends ReactWidget {
+export declare class RunningTerminals extends SidePanel implements IMovableSectionSource, IMovableSectionDestination {
     constructor(options: RunningTerminals.IOptions);
+    get accordionPanel(): AccordionPanel;
+    get sectionAdded(): ISignal<this, ISectionEntry>;
+    get sections(): ReadonlyArray<Widget>;
+    getSections(): ReadonlyArray<ISectionEntry>;
+    removeSectionById(sectionId: string): Widget | null;
+    reinsertSection(widget: Widget): void;
+    addSection(widget: Widget): void;
+    removeSectionWidget(widget: Widget): void;
+    /**
+     * The layout restorer stores a section as collapsed whenever its panel is off
+     * screen at save time, so it can come back collapsed without the user asking.
+     */
+    expandOwnSection(): void;
+    /**
+     * The move plugin reconciles persisted moves only against sections announced
+     * after `registerSource`, and this panel builds its section in the constructor.
+     */
+    announceSections(): void;
     dispose(): void;
-    protected render(): React.ReactElement;
+    private _sectionEntry;
     private _registry;
-    private _trans;
-    private _iconForCommand;
-    private _onActivate;
-    private _onShutdown;
-    private _onShutdownAll;
-    private _onCreate;
+    private _section;
+    private _sectionAdded;
 }
 export declare namespace RunningTerminals {
     interface IOptions {

package/lib/terminals/widget.js

@@ -1,5 +1,6 @@
 import { nullTranslator } from '@jupyterlab/translation';
-import { addIcon, closeIcon, ReactWidget, stopIcon, terminalIcon, UseSignal } from '@jupyterlab/ui-components';
+import { addIcon, closeIcon, PanelWithToolbar, ReactWidget, SidePanel, stopIcon, terminalIcon, ToolbarButton, UseSignal } from '@jupyterlab/ui-components';
+import { Signal } from '@lumino/signaling';
 import * as React from 'react';
 /**
  * Id of the panel widget. Used for layout restoration and as the handle
@@ -7,37 +8,112 @@ import * as React from 'react';
  */
 const RUNNING_TERMINALS_ID = 'xtralab-running-terminals';
 /**
- * Left-sidebar panel listing every running terminal session. It is the
- * sidebar counterpart of the launcher's terminal tiles: where the
- * launcher *starts* sessions, this panel surfaces the ones already
- * running so the user can jump back to a backgrounded agent — including
- * sessions whose tab has been closed but which are still alive on the
- * server. Each row is labelled with the session's title and, for a session
- * running a coding agent, a smaller line below it showing the agent's latest
- * line of output (from {@link SessionRegistry.activityFor}).
- *
- * Backed by {@link SessionRegistry}: a `UseSignal` re-renders the list
- * whenever the registry emits `stateChanged`, so it tracks
- * `runningChanged` and the agent-title cache without any local state.
- * Click behavior (activate vs. reopen, shutdown, new terminal) is
- * delegated to plugin-supplied callbacks so the widget never imports
- * `app`.
+ * Id of the accordion section holding the terminals list. Persisted by the
+ * movable-sections plugin, so it must stay stable across releases.
  */
-export class RunningTerminals extends ReactWidget {
+const TERMINALS_SECTION_ID = 'xtralab-terminals-section';
+/**
+ * Left-sidebar panel listing every running terminal session, including the
+ * sessions whose tab is closed but which are still alive on the server. The
+ * list is a single movable "Terminals" section.
+ */
+export class RunningTerminals extends SidePanel {
     constructor(options) {
         var _a;
         super();
+        this._sectionAdded = new Signal(this);
         this._registry = options.registry;
-        this._trans = (_a = options.trans) !== null && _a !== void 0 ? _a : nullTranslator.load('jupyterlab');
-        this._iconForCommand = options.iconForCommand;
-        this._onActivate = options.onActivate;
-        this._onShutdown = options.onShutdown;
-        this._onShutdownAll = options.onShutdownAll;
-        this._onCreate = options.onCreate;
+        const trans = (_a = options.trans) !== null && _a !== void 0 ? _a : nullTranslator.load('jupyterlab');
         this.id = RUNNING_TERMINALS_ID;
         this.title.icon = terminalIcon;
-        this.title.caption = this._trans.__('Running Terminals');
+        this.title.caption = trans.__('Running Terminals');
         this.addClass('jp-xtralab-Terminals');
+        const section = (this._section = new PanelWithToolbar());
+        section.id = TERMINALS_SECTION_ID;
+        section.title.label = trans.__('Terminals');
+        section.addClass('jp-xtralab-Terminals-section');
+        const shutdownAll = new ToolbarButton({
+            icon: stopIcon,
+            onClick: options.onShutdownAll,
+            tooltip: trans.__('Shut Down All Terminals'),
+            enabled: this._registry.sessionNames().length > 0
+        });
+        this._registry.stateChanged.connect(() => {
+            shutdownAll.enabled = this._registry.sessionNames().length > 0;
+        });
+        section.toolbar.addItem('shutdown-all', shutdownAll);
+        const newTerminal = new ToolbarButton({
+            icon: addIcon,
+            onClick: () => {
+                // Anchor whatever the plugin shows (usually an agent menu) to the
+                // button's bottom-left, in the viewport coordinates `Menu.open` wants.
+                const rect = newTerminal.node.getBoundingClientRect();
+                options.onCreate({ x: rect.left, y: rect.bottom });
+            },
+            tooltip: trans.__('New Terminal')
+        });
+        section.toolbar.addItem('new-terminal', newTerminal);
+        section.addWidget(new TerminalsListing({
+            registry: this._registry,
+            trans,
+            iconForCommand: options.iconForCommand,
+            onActivate: options.onActivate,
+            onShutdown: options.onShutdown
+        }));
+        this.addWidget(section);
+    }
+    get accordionPanel() {
+        return this.content;
+    }
+    get sectionAdded() {
+        return this._sectionAdded;
+    }
+    get sections() {
+        return this.accordionPanel.widgets.filter(w => w !== this._section);
+    }
+    getSections() {
+        const entry = this._sectionEntry();
+        return entry ? [entry] : [];
+    }
+    removeSectionById(sectionId) {
+        if (sectionId !== TERMINALS_SECTION_ID ||
+            this._section.parent !== this.content) {
+            return null;
+        }
+        this._section.parent = null;
+        return this._section;
+    }
+    reinsertSection(widget) {
+        this.addWidget(widget);
+    }
+    addSection(widget) {
+        this.addWidget(widget);
+    }
+    removeSectionWidget(widget) {
+        if (widget.parent === this.content) {
+            widget.parent = null;
+        }
+    }
+    /**
+     * The layout restorer stores a section as collapsed whenever its panel is off
+     * screen at save time, so it can come back collapsed without the user asking.
+     */
+    expandOwnSection() {
+        const accordion = this.accordionPanel;
+        const index = Array.from(accordion.widgets).indexOf(this._section);
+        if (index >= 0) {
+            accordion.expand(index);
+        }
+    }
+    /**
+     * The move plugin reconciles persisted moves only against sections announced
+     * after `registerSource`, and this panel builds its section in the constructor.
+     */
+    announceSections() {
+        const entry = this._sectionEntry();
+        if (entry) {
+            this._sectionAdded.emit(entry);
+        }
     }
     dispose() {
         if (this.isDisposed) {
@@ -48,54 +124,63 @@ export class RunningTerminals extends ReactWidget {
         this._registry.dispose();
         super.dispose();
     }
+    _sectionEntry() {
+        const accordion = this.accordionPanel;
+        const index = Array.from(accordion.widgets).indexOf(this._section);
+        const titleNode = accordion.titles[index];
+        if (index < 0 || !titleNode) {
+            return null;
+        }
+        return {
+            id: TERMINALS_SECTION_ID,
+            titleNode,
+            widget: this._section
+        };
+    }
+}
+/**
+ * The body of the Terminals section.
+ */
+class TerminalsListing extends ReactWidget {
+    constructor(options) {
+        super();
+        this._options = options;
+        this.addClass('jp-xtralab-Terminals-listing');
+    }
     render() {
-        return (React.createElement(UseSignal, { signal: this._registry.stateChanged }, () => (React.createElement(RunningTerminalsComponent, { registry: this._registry, trans: this._trans, iconForCommand: this._iconForCommand, onActivate: this._onActivate, onShutdown: this._onShutdown, onShutdownAll: this._onShutdownAll, onCreate: this._onCreate }))));
+        return (React.createElement(UseSignal, { signal: this._options.registry.stateChanged }, () => (React.createElement(RunningTerminalsComponent, { registry: this._options.registry, trans: this._options.trans, iconForCommand: this._options.iconForCommand, onActivate: this._options.onActivate, onShutdown: this._options.onShutdown }))));
     }
 }
 function RunningTerminalsComponent(props) {
-    const { registry, trans, iconForCommand, onActivate, onShutdown, onShutdownAll, onCreate } = props;
+    const { registry, trans, iconForCommand, onActivate, onShutdown } = props;
     const names = registry.sessionNames();
     // The session whose terminal is the current widget in the main area, so its
     // row can be highlighted. `null` when the current tab is a notebook or any
     // other non-terminal widget.
     const currentName = registry.currentSessionName();
-    return (React.createElement("div", { className: "jp-xtralab-Terminals-body" },
-        React.createElement("div", { className: "jp-xtralab-Terminals-header" },
-            React.createElement("h2", { className: "jp-xtralab-Terminals-title" }, trans.__('Terminals')),
-            React.createElement("div", { className: "jp-xtralab-Terminals-actions" },
-                React.createElement("button", { type: "button", className: "jp-xtralab-Terminals-action jp-xtralab-Terminals-shutdown-all", onClick: onShutdownAll, disabled: names.length === 0, title: trans.__('Shut Down All Terminals'), "aria-label": trans.__('Shut Down All Terminals') },
-                    React.createElement(stopIcon.react, { tag: "span", verticalAlign: "middle" })),
-                React.createElement("button", { type: "button", className: "jp-xtralab-Terminals-action jp-xtralab-Terminals-new", onClick: event => {
-                        // Anchor whatever the plugin shows (usually an agent menu) to
-                        // the button's bottom-left, in viewport coordinates — what
-                        // `Menu.open(x, y)` expects.
-                        const rect = event.currentTarget.getBoundingClientRect();
-                        onCreate({ x: rect.left, y: rect.bottom });
-                    }, title: trans.__('New Terminal'), "aria-label": trans.__('New Terminal'), "aria-haspopup": "menu" },
-                    React.createElement(addIcon.react, { tag: "span", verticalAlign: "middle" })))),
-        names.length === 0 ? (React.createElement("p", { className: "jp-xtralab-Terminals-empty" }, trans.__('No running terminals.'))) : (React.createElement("ul", { className: "jp-xtralab-Terminals-list" }, names.map(name => {
-            const label = registry.labelFor(name);
-            const hasWidget = registry.widgetFor(name) !== null;
-            const tooltip = hasWidget
-                ? trans.__('Activate %1', label)
-                : trans.__('Reopen %1', label);
-            // The running agent's logo (e.g. Claude), or the plain terminal
-            // icon when nothing recognised is running in the session.
-            const RowIcon = iconForCommand(registry.agentCommandFor(name)).react;
-            const isCurrent = name === currentName;
-            // The latest line of output from the session's agent, shown as a
-            // smaller line under the title; `null` for rows with nothing to
-            // surface (no agent running, or no open tab to read a live buffer).
-            const activity = registry.activityFor(name);
-            return (React.createElement("li", { key: name, className: isCurrent
-                    ? 'jp-xtralab-Terminals-item jp-mod-current'
-                    : 'jp-xtralab-Terminals-item' },
-                React.createElement("button", { type: "button", className: "jp-xtralab-Terminals-item-activate", onClick: () => onActivate(name), title: tooltip, "aria-label": tooltip, "aria-current": isCurrent || undefined },
-                    React.createElement(RowIcon, { tag: "span", className: "jp-xtralab-Terminals-item-icon", verticalAlign: "middle" }),
-                    React.createElement("span", { className: "jp-xtralab-Terminals-item-text" },
-                        React.createElement("span", { className: "jp-xtralab-Terminals-item-label" }, label),
-                        activity ? (React.createElement("span", { className: "jp-xtralab-Terminals-item-detail" }, activity)) : null)),
-                React.createElement("button", { type: "button", className: "jp-xtralab-Terminals-item-close", onClick: () => onShutdown(name), title: trans.__('Shut down %1', label), "aria-label": trans.__('Shut down %1', label) },
-                    React.createElement(closeIcon.react, { tag: "span", verticalAlign: "middle" }))));
-        })))));
+    return (React.createElement("div", { className: "jp-xtralab-Terminals-body" }, names.length === 0 ? (React.createElement("p", { className: "jp-xtralab-Terminals-empty" }, trans.__('No running terminals.'))) : (React.createElement("ul", { className: "jp-xtralab-Terminals-list" }, names.map(name => {
+        const label = registry.labelFor(name);
+        const hasWidget = registry.widgetFor(name) !== null;
+        const tooltip = hasWidget
+            ? trans.__('Activate %1', label)
+            : trans.__('Reopen %1', label);
+        // The running agent's logo (e.g. Claude), or the plain terminal
+        // icon when nothing recognised is running in the session.
+        const RowIcon = iconForCommand(registry.agentCommandFor(name)).react;
+        const isCurrent = name === currentName;
+        // The latest line of output from the session's agent, shown as a
+        // smaller line under the title; `null` for rows with nothing to
+        // surface (no agent running, or no open tab to read a live buffer).
+        const activity = registry.activityFor(name);
+        return (React.createElement("li", { key: name, className: isCurrent
+                ? 'jp-xtralab-Terminals-item jp-mod-current'
+                : 'jp-xtralab-Terminals-item' },
+            React.createElement("button", { type: "button", className: "jp-xtralab-Terminals-item-activate", onClick: () => onActivate(name), title: tooltip, "aria-label": tooltip, "aria-current": isCurrent || undefined },
+                React.createElement(RowIcon, { tag: "span", className: "jp-xtralab-Terminals-item-icon", verticalAlign: "middle" }),
+                React.createElement("span", { className: "jp-xtralab-Terminals-item-text" },
+                    React.createElement("span", { className: "jp-xtralab-Terminals-item-label" }, label),
+                    activity ? (React.createElement("span", { className: "jp-xtralab-Terminals-item-detail" }, activity)) : null)),
+            React.createElement("button", { type: "button", className: "jp-xtralab-Terminals-item-close", onClick: () => onShutdown(name), title: trans.__('Shut down %1', label), "aria-label": trans.__('Shut down %1', label) },
+                React.createElement(closeIcon.react, { tag: "span", verticalAlign: "middle" }))));
+    })))));
 }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "xtralab",
-    "version": "0.14.0",
+    "version": "0.15.0",
     "description": "An opinionated JupyterLab meta-package that bundles a curated set of extensions, ships a path-first file browser, renders jupyterlab-git's text, notebook and image diffs with its own viewers, and applies a quieter default workspace configuration.",
     "keywords": [
         "jupyter",

package/schema/launcher.json

@@ -8,7 +8,7 @@
   "properties": {
     "agents": {
       "title": "Agents",
-      "description": "Override or extend the built-in list of agents shown on the launcher. Each entry must include an `id`. When the id matches a built-in (claude, codex, antigravity, copilot, goose, opencode, kiro, mistral-vibe), the fields you set override the corresponding defaults; leave a field out to keep the default. New ids define brand-new cards. Set `enabled: false` to hide a default. Changing a built-in's `command` (for example to a shell alias like `ccm`) keeps the card visible even though the alias isn't on PATH; use `requireAvailable: false` only when you want to skip the check without changing the command. The full built-in list is shown as the default below, so you can copy an entry and tweak it in place.",
+      "description": "Override or extend the built-in list of agents shown on the launcher. Each entry must include an `id`. When the id matches a built-in (claude, codex, antigravity, copilot, goose, opencode, kiro, mistral-vibe, pi), the fields you set override the corresponding defaults; leave a field out to keep the default. New ids define brand-new cards. Set `enabled: false` to hide a default. Changing a built-in's `command` (for example to a shell alias like `ccm`) keeps the card visible even though the alias isn't on PATH; use `requireAvailable: false` only when you want to skip the check without changing the command. The full built-in list is shown as the default below, so you can copy an entry and tweak it in place. Saved entries are merged into the built-in list by id, so this settings view always shows every built-in agent alongside your overrides.",
       "type": "array",
       "default": [],
       "items": {
@@ -69,7 +69,7 @@
     },
     "editors": {
       "title": "Editors",
-      "description": "Override or extend the terminal editors offered in the launcher's Open section (and recognized in the Terminals panel). Each entry must include an `id`. When the id matches a built-in (nvim, vim), the fields you set override the corresponding defaults; leave a field out to keep the default. New ids define additional editors. The launcher shows a single tile — the first editor, by `rank`, whose `command` is on PATH (Neovim before Vim by default). Set `enabled: false` to hide a built-in; disable both to remove the tile entirely. Changing a built-in's `command` (for example to a shell alias) keeps the tile visible even though the alias isn't on PATH; use `requireAvailable: false` only when you want to skip the check without changing the command. The full built-in list is shown as the default below, so you can copy an entry and tweak it in place.",
+      "description": "Override or extend the terminal editors offered in the launcher's Open section (and recognized in the Terminals panel). Each entry must include an `id`. When the id matches a built-in (nvim, vim), the fields you set override the corresponding defaults; leave a field out to keep the default. New ids define additional editors. The launcher shows a single tile — the first editor, by `rank`, whose `command` is on PATH (Neovim before Vim by default). Set `enabled: false` to hide a built-in; disable both to remove the tile entirely. Changing a built-in's `command` (for example to a shell alias) keeps the tile visible even though the alias isn't on PATH; use `requireAvailable: false` only when you want to skip the check without changing the command. The full built-in list is shown as the default below, so you can copy an entry and tweak it in place. Saved entries are merged into the built-in list by id, so this settings view always shows every built-in editor alongside your overrides.",
       "type": "array",
       "default": [],
       "items": {