jupyterlab_nb_venv_kernels_ui_extension 1.2.11

package/LICENSE

@@ -0,0 +1,29 @@
+BSD 3-Clause License
+
+Copyright (c) 2025, Stellars Henson
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

package/README.md

@@ -0,0 +1,47 @@
+# jupyterlab_nb_venv_kernels_ui_extension
+
+[![GitHub Actions](https://github.com/stellarshenson/jupyterlab_nb_venv_kernels_ui_extension/actions/workflows/build.yml/badge.svg)](https://github.com/stellarshenson/jupyterlab_nb_venv_kernels_ui_extension/actions/workflows/build.yml)
+[![npm version](https://img.shields.io/npm/v/jupyterlab_nb_venv_kernels_ui_extension.svg)](https://www.npmjs.com/package/jupyterlab_nb_venv_kernels_ui_extension)
+[![PyPI version](https://img.shields.io/pypi/v/jupyterlab-nb-venv-kernels-ui-extension.svg)](https://pypi.org/project/jupyterlab-nb-venv-kernels-ui-extension/)
+[![Total PyPI downloads](https://static.pepy.tech/badge/jupyterlab-nb-venv-kernels-ui-extension)](https://pepy.tech/project/jupyterlab-nb-venv-kernels-ui-extension)
+[![JupyterLab 4](https://img.shields.io/badge/JupyterLab-4-orange.svg)](https://jupyterlab.readthedocs.io/en/stable/)
+[![Brought To You By KOLOMOLO](https://img.shields.io/badge/Brought%20To%20You%20By-KOLOMOLO-00ffff?style=flat)](https://kolomolo.com)
+[![Donate PayPal](https://img.shields.io/badge/Donate-PayPal-blue?style=flat)](https://www.paypal.com/donate/?hosted_button_id=B4KPBJDLLXTSA)
+
+> [!IMPORTANT]
+> **Package Renamed**: This package was renamed from `jupyterlab_launcher_navigate_to_kernel_extension` to `jupyterlab_nb_venv_kernels_ui_extension` in version 1.2.8. If you have the old package installed, please uninstall it first: `pip uninstall jupyterlab-launcher-navigate-to-kernel-extension`
+
+Right-click on any kernel launcher card to navigate to its project directory or open a terminal there. Intended to help navigate around a busy workspace with many projects. Similar to [jupyterlab_terminal_show_in_file_browser_extension](https://github.com/stellarshenson/jupyterlab_terminal_show_in_file_browser_extension).
+
+![](.resources/screenshot.png)
+
+## Features
+
+**Context Menu (right-click on kernel launcher card)**:
+- **Show in File Browser** - Navigate to the kernel's project root
+- **Open Terminal at Location** - Open terminal at the kernel's project directory
+- **Unregister Kernel** - Remove kernel from `nb_venv_kernels` registry (requires `nb_venv_kernels`)
+- **Remove Environment** - Permanently delete local `.venv` environments with confirmation (requires `nb_venv_kernels`)
+
+**Kernel Menu**:
+- **Scan for Virtual Environments** - Discover and register new virtual environments in your workspace (requires `nb_venv_kernels`)
+
+**General**:
+- **Project-aware navigation** - For `.venv` environments, navigates to project root (one level up from `.venv`)
+- **Dynamic kernel support** - Works with `nb_conda_kernels` and `nb_venv_kernels` providers
+
+## Requirements
+
+- JupyterLab >= 4.0.0
+
+## Install
+
+```bash
+pip install jupyterlab-nb-venv-kernels-ui-extension
+```
+
+## Uninstall
+
+```bash
+pip uninstall jupyterlab_nb_venv_kernels_ui_extension
+```

package/lib/index.d.ts

@@ -0,0 +1,6 @@
+import { JupyterFrontEndPlugin } from '@jupyterlab/application';
+/**
+ * Initialization data for the jupyterlab_nb_venv_kernels_ui_extension extension.
+ */
+declare const plugin: JupyterFrontEndPlugin<void>;
+export default plugin;

package/lib/index.js

@@ -0,0 +1,518 @@
+import { IDefaultFileBrowser } from '@jupyterlab/filebrowser';
+import { ILauncher } from '@jupyterlab/launcher';
+import { ITerminalTracker } from '@jupyterlab/terminal';
+import { showErrorMessage, showDialog, Dialog } from '@jupyterlab/apputils';
+import { ServerConnection } from '@jupyterlab/services';
+import { URLExt, PageConfig } from '@jupyterlab/coreutils';
+import { Widget } from '@lumino/widgets';
+/**
+ * Command IDs for the extension.
+ */
+const SHOW_IN_BROWSER_CMD = 'launcher:show-kernel-in-file-browser';
+const OPEN_TERMINAL_CMD = 'launcher:open-terminal-at-kernel';
+const UNREGISTER_KERNEL_CMD = 'launcher:unregister-venv-kernel';
+const REMOVE_ENVIRONMENT_CMD = 'launcher:remove-venv-environment';
+/**
+ * Command ID for nb_venv_kernels refresh (provided by that extension).
+ */
+const NB_VENV_KERNELS_REFRESH_CMD = 'nb_venv_kernels:refresh';
+/**
+ * Store for the last right-clicked kernel display name.
+ * This is set when a context menu is opened on a launcher card.
+ */
+let lastClickedKernelName = null;
+/**
+ * Flag indicating whether nb_venv_kernels extension is available.
+ * Checked once at startup.
+ */
+let nbVenvKernelsAvailable = false;
+/**
+ * Fetch the kernel path information from the server.
+ *
+ * @param displayName - The display name of the kernel
+ * @returns Promise resolving to kernel path info or null if not available
+ */
+async function fetchKernelPath(displayName) {
+    const settings = ServerConnection.makeSettings();
+    const url = URLExt.join(settings.baseUrl, 'api', 'kernel-path', encodeURIComponent(displayName));
+    try {
+        const response = await ServerConnection.makeRequest(url, {}, settings);
+        if (!response.ok) {
+            const data = (await response.json());
+            console.warn(`Failed to get kernel path: ${data.error}`);
+            return null;
+        }
+        const data = (await response.json());
+        return data;
+    }
+    catch (error) {
+        console.error('Error fetching kernel path:', error);
+        return null;
+    }
+}
+/**
+ * Check if nb_venv_kernels extension is available.
+ *
+ * @returns Promise resolving to true if available, false otherwise
+ */
+async function checkNbVenvKernelsAvailable() {
+    const settings = ServerConnection.makeSettings();
+    const url = URLExt.join(settings.baseUrl, 'nb-venv-kernels', 'environments');
+    try {
+        const response = await ServerConnection.makeRequest(url, {}, settings);
+        return response.ok;
+    }
+    catch (error) {
+        console.debug('nb_venv_kernels extension not installed:', error);
+        return false;
+    }
+}
+/**
+ * Fetch list of venv environments from nb_venv_kernels API.
+ *
+ * @returns Promise resolving to environments list or null if not available
+ */
+async function fetchVenvEnvironments() {
+    const settings = ServerConnection.makeSettings();
+    const url = URLExt.join(settings.baseUrl, 'nb-venv-kernels', 'environments');
+    try {
+        const response = await ServerConnection.makeRequest(url, {}, settings);
+        if (!response.ok) {
+            console.warn('nb_venv_kernels API not available');
+            return null;
+        }
+        const data = (await response.json());
+        return data;
+    }
+    catch (error) {
+        console.debug('nb_venv_kernels extension not installed:', error);
+        return null;
+    }
+}
+/**
+ * Find a venv environment matching the given display name.
+ *
+ * @param displayName - The kernel display name to match
+ * @returns The matching environment or null
+ */
+async function findVenvEnvironment(displayName) {
+    const envData = await fetchVenvEnvironments();
+    if (!envData) {
+        return null;
+    }
+    // Find matching environment by name
+    // Display name patterns: "Python (envname)", "envname", "Python 3 (envname)"
+    for (const env of envData.environments) {
+        // Skip conda environments - they can't be unregistered via nb_venv_kernels
+        if (env.type === 'conda') {
+            continue;
+        }
+        const envName = env.name || '';
+        const customName = env.custom_name || '';
+        // Check if display_name contains the environment name
+        if ((envName && displayName.includes(envName)) ||
+            (customName && displayName.includes(customName))) {
+            return env;
+        }
+    }
+    return null;
+}
+/**
+ * Unregister a venv environment via nb_venv_kernels API.
+ *
+ * @param envPath - The path of the environment to unregister
+ * @returns Promise resolving to unregister result
+ */
+async function unregisterVenvKernel(envPath) {
+    const settings = ServerConnection.makeSettings();
+    const url = URLExt.join(settings.baseUrl, 'nb-venv-kernels', 'unregister');
+    try {
+        const response = await ServerConnection.makeRequest(url, {
+            method: 'POST',
+            body: JSON.stringify({ path: envPath })
+        }, settings);
+        const data = (await response.json());
+        if (!response.ok) {
+            return {
+                success: false,
+                error: data.error || 'Failed to unregister kernel'
+            };
+        }
+        return { success: true, message: data.message };
+    }
+    catch (error) {
+        console.error('Error unregistering kernel:', error);
+        return {
+            success: false,
+            error: `Network error: ${error}`
+        };
+    }
+}
+/**
+ * Check if an environment path is a local .venv environment.
+ * Local environments have .venv in their path.
+ *
+ * @param envPath - The environment path to check
+ * @returns true if the environment is local (.venv based)
+ */
+function isLocalVenvEnvironment(envPath) {
+    return envPath.includes('/.venv') || envPath.includes('\\.venv');
+}
+/**
+ * Remove a directory via the Jupyter server contents API.
+ *
+ * @param dirPath - The absolute path to the directory to remove
+ * @param serverRoot - The server root directory
+ * @returns Promise resolving to success status and optional error message
+ */
+async function removeDirectory(dirPath, serverRoot) {
+    const settings = ServerConnection.makeSettings();
+    // Determine relative path for the contents API
+    let relativePath = null;
+    // If path doesn't start with '/', it's already relative - use it directly
+    if (!dirPath.startsWith('/')) {
+        relativePath = dirPath;
+        console.debug(`Path is already relative: ${relativePath}`);
+    }
+    else {
+        // Convert absolute path to relative path
+        relativePath = toRelativePath(dirPath, serverRoot);
+        // If standard conversion fails, try alternative approaches
+        if (relativePath === null) {
+            console.debug(`Path conversion failed: dirPath="${dirPath}", serverRoot="${serverRoot}"`);
+            // Fallback: if serverRoot is empty or '~', try using home-relative path
+            if (!serverRoot || serverRoot === '~' || serverRoot === '') {
+                // Extract path from after '/home/username' or similar
+                const homeMatch = dirPath.match(/^\/(?:home|Users)\/[^/]+\/(.+)$/);
+                if (homeMatch) {
+                    relativePath = homeMatch[1];
+                    console.debug(`Using home-relative fallback path: ${relativePath}`);
+                }
+            }
+            // If still null, the path is truly outside workspace
+            if (relativePath === null) {
+                return {
+                    success: false,
+                    error: `Environment path "${dirPath}" is outside the workspace (root: "${serverRoot}") and cannot be removed.`
+                };
+            }
+        }
+    }
+    const url = URLExt.join(settings.baseUrl, 'api', 'contents', relativePath);
+    try {
+        const response = await ServerConnection.makeRequest(url, { method: 'DELETE' }, settings);
+        if (!response.ok) {
+            const text = await response.text();
+            return {
+                success: false,
+                error: `Server error: ${response.status} ${text}`
+            };
+        }
+        return { success: true };
+    }
+    catch (error) {
+        console.error('Error removing directory:', error);
+        return {
+            success: false,
+            error: `Network error: ${error}`
+        };
+    }
+}
+/**
+ * Expand tilde in path using the home directory extracted from absolutePath.
+ *
+ * @param path - Path that may contain ~
+ * @param absolutePath - An absolute path to extract home directory from
+ * @returns Path with ~ expanded, or original if expansion not possible
+ */
+function expandTilde(path, absolutePath) {
+    if (!path.startsWith('~')) {
+        return path;
+    }
+    // Extract home directory from absolute path
+    // Matches /home/username or /Users/username
+    const match = absolutePath.match(/^(\/(?:home|Users)\/[^/]+)/);
+    if (!match) {
+        return path;
+    }
+    const homedir = match[1];
+    if (path === '~') {
+        return homedir;
+    }
+    if (path.startsWith('~/')) {
+        return homedir + path.slice(1);
+    }
+    return path;
+}
+/**
+ * Convert an absolute filesystem path to a path relative to the server root.
+ *
+ * @param absolutePath - The absolute filesystem path
+ * @param serverRoot - The server's root directory (may contain ~)
+ * @returns The relative path for the file browser, or null if outside server root
+ */
+function toRelativePath(absolutePath, serverRoot) {
+    // Normalize path - ensure no trailing slashes
+    const normalizedPath = absolutePath.replace(/\/+$/, '');
+    // Expand tilde in serverRoot and normalize
+    const normalizedRoot = expandTilde(serverRoot, absolutePath).replace(/\/+$/, '');
+    // Check if path is the server root
+    if (normalizedPath === normalizedRoot) {
+        return '';
+    }
+    // Check if path is inside the server root
+    const rootPrefix = normalizedRoot + '/';
+    if (normalizedPath.startsWith(rootPrefix)) {
+        return normalizedPath.slice(rootPrefix.length);
+    }
+    // Path is outside the server root
+    return null;
+}
+/**
+ * Extract kernel display name from a launcher card element.
+ *
+ * @param element - The clicked element or its parent launcher card
+ * @returns The kernel display name or null if not found
+ */
+function extractKernelNameFromCard(element) {
+    // Find the launcher card (might be the element itself or a parent)
+    const card = element.closest('.jp-LauncherCard');
+    if (!card) {
+        return null;
+    }
+    // Find the label element within the card
+    const label = card.querySelector('.jp-LauncherCard-label');
+    if (label && label.textContent) {
+        return label.textContent.trim();
+    }
+    // Fallback: try the title attribute
+    if (card.title) {
+        return card.title;
+    }
+    return null;
+}
+/**
+ * Setup event listener to capture right-clicked kernel name.
+ */
+function setupContextMenuCapture() {
+    document.addEventListener('contextmenu', (event) => {
+        const target = event.target;
+        if (target) {
+            const card = target.closest('.jp-LauncherCard');
+            if (card) {
+                lastClickedKernelName = extractKernelNameFromCard(target);
+            }
+        }
+    }, true); // Use capture phase to get event before context menu
+}
+/**
+ * Initialization data for the jupyterlab_nb_venv_kernels_ui_extension extension.
+ */
+const plugin = {
+    id: 'jupyterlab_nb_venv_kernels_ui_extension:plugin',
+    description: "Right-click kernel launcher cards to navigate file browser to kernel's location or open terminal there",
+    autoStart: true,
+    requires: [IDefaultFileBrowser],
+    optional: [ILauncher, ITerminalTracker],
+    activate: (app, fileBrowser, launcher, terminalTracker) => {
+        console.log('JupyterLab extension jupyterlab_nb_venv_kernels_ui_extension is activated!');
+        const { commands } = app;
+        // Get the server root directory from PageConfig
+        const serverRoot = PageConfig.getOption('serverRoot');
+        // Setup event listener to capture kernel name on right-click
+        setupContextMenuCapture();
+        // Check if nb_venv_kernels is available (for unregister feature)
+        checkNbVenvKernelsAvailable().then(available => {
+            nbVenvKernelsAvailable = available;
+            if (available) {
+                console.log('nb_venv_kernels extension detected - unregister feature enabled');
+            }
+        });
+        // Add the "Show in File Browser" command
+        commands.addCommand(SHOW_IN_BROWSER_CMD, {
+            label: 'Show in File Browser',
+            caption: "Navigate file browser to kernel's directory",
+            isEnabled: () => lastClickedKernelName !== null,
+            execute: async () => {
+                if (!lastClickedKernelName) {
+                    await showErrorMessage('No Kernel Selected', 'Could not determine which kernel was selected.');
+                    return;
+                }
+                const kernelInfo = await fetchKernelPath(lastClickedKernelName);
+                if (!kernelInfo) {
+                    await showErrorMessage('Kernel Not Found', `Could not find path information for kernel "${lastClickedKernelName}".`);
+                    return;
+                }
+                // Prefer env_path (conda environment) if available, otherwise use resource_dir
+                const targetPath = kernelInfo.env_path || kernelInfo.resource_dir;
+                // Convert to relative path for file browser
+                const relativePath = toRelativePath(targetPath, serverRoot);
+                // If outside workspace, fallback to workspace root
+                const navigatePath = relativePath === null ? '' : relativePath;
+                try {
+                    const absolutePath = navigatePath === '' ? '/' : '/' + navigatePath;
+                    await fileBrowser.model.cd(absolutePath);
+                }
+                catch (error) {
+                    console.error('Failed to navigate file browser:', error);
+                    await showErrorMessage('Navigation Error', `Failed to navigate to: ${targetPath}\nError: ${error}`);
+                }
+            }
+        });
+        // Add the "Open Terminal at location" command
+        commands.addCommand(OPEN_TERMINAL_CMD, {
+            label: 'Open Terminal at Location',
+            caption: "Open a terminal at the kernel's directory",
+            isEnabled: () => lastClickedKernelName !== null && terminalTracker !== null,
+            execute: async () => {
+                if (!lastClickedKernelName) {
+                    await showErrorMessage('No Kernel Selected', 'Could not determine which kernel was selected.');
+                    return;
+                }
+                const kernelInfo = await fetchKernelPath(lastClickedKernelName);
+                if (!kernelInfo) {
+                    await showErrorMessage('Kernel Not Found', `Could not find path information for kernel "${lastClickedKernelName}".`);
+                    return;
+                }
+                // Prefer env_path (conda environment) if available, otherwise use resource_dir
+                const targetPath = kernelInfo.env_path || kernelInfo.resource_dir;
+                // Convert to relative path for terminal (terminal:create-new requires relative path)
+                const relativePath = toRelativePath(targetPath, serverRoot);
+                // If outside workspace, use empty string (workspace root)
+                const terminalCwd = relativePath === null ? '' : relativePath;
+                try {
+                    // Open a new terminal with relative path
+                    await commands.execute('terminal:create-new', {
+                        cwd: terminalCwd
+                    });
+                }
+                catch (error) {
+                    console.error('Failed to open terminal:', error);
+                    await showErrorMessage('Terminal Error', `Failed to open terminal at: ${targetPath}\nError: ${error}`);
+                }
+            }
+        });
+        // Add the "Unregister Kernel" command (shown when nb_venv_kernels is available)
+        commands.addCommand(UNREGISTER_KERNEL_CMD, {
+            label: 'Unregister Kernel',
+            caption: 'Remove this kernel from nb_venv_kernels registry',
+            isEnabled: () => lastClickedKernelName !== null && nbVenvKernelsAvailable,
+            isVisible: () => nbVenvKernelsAvailable,
+            execute: async () => {
+                if (!lastClickedKernelName) {
+                    await showErrorMessage('No Kernel Selected', 'Could not determine which kernel was selected.');
+                    return;
+                }
+                // Find the venv environment for this kernel
+                const env = await findVenvEnvironment(lastClickedKernelName);
+                if (!env) {
+                    await showErrorMessage('Cannot Unregister', `"${lastClickedKernelName}" is not managed by nb_venv_kernels.`);
+                    return;
+                }
+                // Unregister the kernel
+                const result = await unregisterVenvKernel(env.path);
+                if (result.success) {
+                    console.log(`Kernel unregistered: ${env.path}`);
+                    // Refresh kernel list so changes are visible immediately
+                    await commands.execute(NB_VENV_KERNELS_REFRESH_CMD).catch(() => {
+                        // Ignore if refresh command not available
+                    });
+                    const bodyWidget = new Widget();
+                    const p1 = document.createElement('p');
+                    p1.textContent = `Successfully unregistered "${env.name}" (${env.path}).`;
+                    const p2 = document.createElement('p');
+                    p2.textContent = `To re-register, run: nb_venv_kernels register ${env.path}`;
+                    bodyWidget.node.appendChild(p1);
+                    bodyWidget.node.appendChild(p2);
+                    await showDialog({
+                        title: 'Kernel Unregistered',
+                        body: bodyWidget,
+                        buttons: [Dialog.okButton()]
+                    });
+                }
+                else {
+                    await showErrorMessage('Unregister Failed', `Failed to unregister kernel: ${result.error}`);
+                }
+            }
+        });
+        // Add the "Remove Environment" command (dangerous - physically removes .venv folder)
+        commands.addCommand(REMOVE_ENVIRONMENT_CMD, {
+            label: 'Remove Environment (dangerous)',
+            caption: 'Physically remove the .venv folder containing this environment',
+            isEnabled: () => lastClickedKernelName !== null && nbVenvKernelsAvailable,
+            isVisible: () => nbVenvKernelsAvailable,
+            execute: async () => {
+                if (!lastClickedKernelName) {
+                    await showErrorMessage('No Kernel Selected', 'Could not determine which kernel was selected.');
+                    return;
+                }
+                // Find the venv environment for this kernel
+                const env = await findVenvEnvironment(lastClickedKernelName);
+                if (!env) {
+                    await showErrorMessage('Cannot Remove', `"${lastClickedKernelName}" is not managed by nb_venv_kernels.`);
+                    return;
+                }
+                // Check if this is a local .venv environment
+                if (!isLocalVenvEnvironment(env.path)) {
+                    const notLocalWidget = new Widget();
+                    const notLocalP1 = document.createElement('p');
+                    notLocalP1.textContent = `"${env.name}" is not a local .venv environment.`;
+                    const notLocalP2 = document.createElement('p');
+                    notLocalP2.textContent = 'Only local environments (with .venv in their path) can be removed.';
+                    notLocalWidget.node.appendChild(notLocalP1);
+                    notLocalWidget.node.appendChild(notLocalP2);
+                    await showDialog({
+                        title: 'Cannot Remove',
+                        body: notLocalWidget,
+                        buttons: [Dialog.okButton()]
+                    });
+                    return;
+                }
+                // Show confirmation dialog
+                const confirmWidget = new Widget();
+                const confirmP1 = document.createElement('p');
+                confirmP1.textContent = `Are you sure you want to permanently remove virtual environment "${env.name}"?`;
+                const confirmP2 = document.createElement('p');
+                confirmP2.textContent = `This will delete: ${env.path}`;
+                const confirmP3 = document.createElement('p');
+                confirmP3.style.fontWeight = 'bold';
+                confirmP3.textContent = 'This action cannot be undone!';
+                confirmWidget.node.appendChild(confirmP1);
+                confirmWidget.node.appendChild(confirmP2);
+                confirmWidget.node.appendChild(confirmP3);
+                const result = await showDialog({
+                    title: 'Remove Environment',
+                    body: confirmWidget,
+                    buttons: [
+                        Dialog.cancelButton(),
+                        Dialog.warnButton({ label: 'Remove' })
+                    ]
+                });
+                if (!result.button.accept) {
+                    return;
+                }
+                // First unregister the kernel
+                const unregisterResult = await unregisterVenvKernel(env.path);
+                if (!unregisterResult.success) {
+                    await showErrorMessage('Remove Failed', `Failed to unregister kernel before removal: ${unregisterResult.error}`);
+                    return;
+                }
+                // Then remove the directory
+                const removeResult = await removeDirectory(env.path, serverRoot);
+                if (removeResult.success) {
+                    console.log(`Environment removed: ${env.path}`);
+                    // Refresh kernel list so changes are visible immediately
+                    await commands.execute(NB_VENV_KERNELS_REFRESH_CMD).catch(() => {
+                        // Ignore if refresh command not available
+                    });
+                    await showErrorMessage('Environment Removed', `Successfully removed "${env.name}" (${env.path}).`);
+                }
+                else {
+                    await showErrorMessage('Remove Failed', `Kernel was unregistered but failed to remove directory: ${removeResult.error}`);
+                }
+            }
+        });
+        console.log(`Commands registered: ${SHOW_IN_BROWSER_CMD}, ${OPEN_TERMINAL_CMD}, ${UNREGISTER_KERNEL_CMD}, ${REMOVE_ENVIRONMENT_CMD}`);
+    }
+};
+export default plugin;