xtralab 0.14.1 → 0.15.0

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.1",
+    "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": {

package/schema/sidebar.json

@@ -1,6 +1,6 @@
 {
   "title": "xtralab sidebar",
-  "description": "Visibility of selected JupyterLab sidebar tabs.",
+  "description": "Visibility of individual sidebar tabs.",
   "jupyter.lab.shortcuts": [],
   "jupyter.lab.menus": {
     "main": [
@@ -17,16 +17,32 @@
                   "type": "submenu",
                   "rank": 12.5,
                   "submenu": {
-                    "id": "jp-mainmenu-view-appearance-left-sidebar",
-                    "label": "Left Sidebar",
+                    "id": "jp-mainmenu-view-appearance-sidebars",
+                    "label": "Sidebars",
                     "items": [
                       {
-                        "command": "xtralab:toggle-default-filebrowser",
+                        "command": "xtralab:toggle-terminals",
                         "rank": 1
                       },
                       {
-                        "command": "xtralab:toggle-running-sessions",
+                        "command": "xtralab:toggle-file-browser",
                         "rank": 2
+                      },
+                      {
+                        "command": "xtralab:toggle-git-panel",
+                        "rank": 3
+                      },
+                      {
+                        "command": "xtralab:toggle-default-filebrowser",
+                        "rank": 4
+                      },
+                      {
+                        "command": "xtralab:toggle-running-sessions",
+                        "rank": 5
+                      },
+                      {
+                        "command": "xtralab:toggle-search-replace",
+                        "rank": 6
                       }
                     ]
                   }
@@ -40,16 +56,40 @@
   },
   "type": "object",
   "properties": {
+    "showTerminals": {
+      "type": "boolean",
+      "title": "Show the terminals panel",
+      "description": "When false, hides the xtralab Terminals (`xtralab-running-terminals`) tab from the sidebar.",
+      "default": true
+    },
+    "showFileBrowser": {
+      "type": "boolean",
+      "title": "Show the xtralab file browser",
+      "description": "When false, hides the xtralab file browser (`xtralab:file-browser`) tab from the sidebar. The default JupyterLab file browser is unaffected.",
+      "default": true
+    },
+    "showGitPanel": {
+      "type": "boolean",
+      "title": "Show the Git panel",
+      "description": "When false, hides the `jp-git-sessions` (Git) tab from the sidebar.",
+      "default": true
+    },
     "showDefaultFileBrowser": {
       "type": "boolean",
       "title": "Show the default JupyterLab file browser",
-      "description": "When false, hides the default `filebrowser` tab from the left sidebar. The xtralab file browser is unaffected.",
+      "description": "When false, hides the default `filebrowser` tab from the sidebar. The xtralab file browser is unaffected.",
       "default": true
     },
     "showRunningSessions": {
       "type": "boolean",
       "title": "Show running terminals and kernels",
-      "description": "When false, hides the `jp-running-sessions` (Running Terminals and Kernels) tab from the left sidebar.",
+      "description": "When false, hides the `jp-running-sessions` (Running Terminals and Kernels) tab from the sidebar.",
+      "default": true
+    },
+    "showSearchReplace": {
+      "type": "boolean",
+      "title": "Show search and replace",
+      "description": "When false, hides the `jp-search-replace` (Search and Replace) tab from the sidebar.",
       "default": true
     }
   },

package/src/customPanel/index.ts

@@ -0,0 +1,104 @@
+import {
+  JupyterFrontEnd,
+  JupyterFrontEndPlugin
+} from '@jupyterlab/application';
+import {
+  IMovableSectionDestination,
+  IMovableSectionRegistry
+} from '@jupyterlab/apputils';
+import {
+  ITranslator,
+  nullTranslator,
+  type TranslationBundle
+} from '@jupyterlab/translation';
+import { SidePanel, tableRowsIcon } from '@jupyterlab/ui-components';
+import { ISignal, Signal } from '@lumino/signaling';
+import { AccordionPanel, Widget } from '@lumino/widgets';
+
+const PLUGIN_ID = 'xtralab:custom-panel';
+
+const CUSTOM_PANEL_ID = 'xtralab-custom-panel';
+
+/**
+ * A sidebar panel holding only the sections moved in from other panels.
+ */
+class CustomPanel extends SidePanel implements IMovableSectionDestination {
+  constructor(options: { trans: TranslationBundle }) {
+    super();
+    this.id = CUSTOM_PANEL_ID;
+    this.title.icon = tableRowsIcon;
+    this.title.caption = options.trans.__('Custom Panel');
+    this.addClass('jp-xtralab-CustomPanel');
+  }
+
+  get accordionPanel(): AccordionPanel {
+    return this.content as AccordionPanel;
+  }
+
+  get sections(): ReadonlyArray<Widget> {
+    return this.content.widgets;
+  }
+
+  get sectionCountChanged(): ISignal<this, number> {
+    return this._sectionCountChanged;
+  }
+
+  addSection(widget: Widget): void {
+    this.addWidget(widget);
+    this._sectionCountChanged.emit(this.content.widgets.length);
+  }
+
+  removeSectionWidget(widget: Widget): void {
+    if (widget.parent !== this.content) {
+      return;
+    }
+    widget.parent = null;
+    this._sectionCountChanged.emit(this.content.widgets.length);
+  }
+
+  private _sectionCountChanged = new Signal<this, number>(this);
+}
+
+/**
+ * Registers "Custom Panel", which takes a sidebar tab only while it hosts a
+ * section.
+ */
+const plugin: JupyterFrontEndPlugin<void> = {
+  id: PLUGIN_ID,
+  description:
+    'A user-assembled sidebar panel hosting sections moved in from other panels; hidden while empty.',
+  autoStart: true,
+  optional: [IMovableSectionRegistry, ITranslator],
+  activate: (
+    app: JupyterFrontEnd,
+    registry: IMovableSectionRegistry | null,
+    translator: ITranslator | null
+  ): void => {
+    if (!registry) {
+      return;
+    }
+    const trans = (translator ?? nullTranslator).load('jupyterlab');
+    const panel = new CustomPanel({ trans });
+
+    // Only a user move should switch the sidebar, not the startup restoration.
+    let restored = false;
+    void app.restored.then(() => {
+      restored = true;
+    });
+
+    panel.sectionCountChanged.connect((_, count) => {
+      if (count > 0 && !panel.parent) {
+        app.shell.add(panel, 'left', { rank: 3 });
+        if (restored) {
+          app.shell.activateById(panel.id);
+        }
+      } else if (count === 0 && panel.parent) {
+        panel.parent = null;
+      }
+    });
+
+    registry.registerTarget(PLUGIN_ID, trans.__('Custom Panel'), panel);
+  }
+};
+
+export default plugin;

package/src/fileBrowser/commands.ts

@@ -512,11 +512,24 @@ export function registerCommands(opts: IRegisterCommandsOptions): () => void {
   // point of view. An empty path is the "workspace root" gesture —
   // there is no tree row for the root itself, so the browser is asked
   // to scroll back to the top and clear its selection instead.
+  // The tree is movable, so surface whichever sidebar widget holds it.
+  const activateTreeHost = (): void => {
+    for (const area of ['left', 'right']) {
+      for (const widget of app.shell.widgets(area)) {
+        if (widget.node.contains(browser.sectionNode)) {
+          app.shell.activateById(widget.id);
+          return;
+        }
+      }
+    }
+    app.shell.activateById(FILE_BROWSER_ID);
+  };
+
   commands.addCommand(CommandIDs.revealPath, {
     label: trans.__('Reveal in File Browser'),
     execute: (args: ReadonlyPartialJSONObject) => {
       const path = (args.path as string | undefined) ?? '';
-      app.shell.activateById(FILE_BROWSER_ID);
+      activateTreeHost();
       if (path.length === 0) {
         browser.scrollToRoot();
       } else {

package/src/fileBrowser/contents.ts

@@ -17,6 +17,36 @@ export function toCanonicalPath(child: Contents.IModel): string {
   return child.type === 'directory' ? `${child.path}${DIR_SUFFIX}` : child.path;
 }
 
+/**
+ * Compute the canonical parent path for a canonical path. Returns
+ * {@link ROOT_LOAD_KEY} for top-level entries.
+ */
+export function parentOf(canonicalPath: string): string {
+  const trimmed = canonicalPath.endsWith(DIR_SUFFIX)
+    ? canonicalPath.slice(0, -DIR_SUFFIX.length)
+    : canonicalPath;
+  const idx = trimmed.lastIndexOf(DIR_SUFFIX);
+  if (idx < 0) {
+    return ROOT_LOAD_KEY;
+  }
+  return `${trimmed.slice(0, idx)}${DIR_SUFFIX}`;
+}
+
+/**
+ * The last segment of a canonical path. Directories keep their trailing
+ * slash, so appending the result to a canonical directory path yields a
+ * canonical path again.
+ */
+export function canonicalBasename(canonicalPath: string): string {
+  const isDir = canonicalPath.endsWith(DIR_SUFFIX);
+  const trimmed = isDir
+    ? canonicalPath.slice(0, -DIR_SUFFIX.length)
+    : canonicalPath;
+  const idx = trimmed.lastIndexOf(DIR_SUFFIX);
+  const base = idx < 0 ? trimmed : trimmed.slice(idx + DIR_SUFFIX.length);
+  return isDir ? `${base}${DIR_SUFFIX}` : base;
+}
+
 /**
  * Strip the trailing slash that `@pierre/trees` uses for canonical directory
  * paths so the value can be sent to the Jupyter contents API.