• Sign In


    • Categories

    Extension Details


    Install
    Nova Jupyter Bridge
    by PatriotEver Lab
    4 Recent Installs | 4 Total Installs
    Privacy-focused Jupyter integration for Nova. Open custom Notebook Studio or official JupyterLab in your default browser or Nova Preview. Features include per-cell Python execution and debugging, breakpoints, debugger controls, local MySQL SQL cells, kernel management, and standard Jupyter notebook support.
    Repository
    Bug Reports
    This extension is allowed to:
    Launch Subprocesses
    Read & Write Clipboard

    Report Abuse

    Readme

    Nova Jupyter Bridge

    Privacy-focused Jupyter notebook integration for Panic Nova.

    Developed by PatriotEver Lab.

    Nova Jupyter Bridge brings interactive Jupyter notebooks into Nova through two independent interfaces:

    • Jupyter Notebook Studio — a custom notebook interface with Python execution, debugging, and local MySQL SQL cells.
    • JupyterLab — the official JupyterLab interface, launched directly from Nova.

    Both interfaces can be opened in your default web browser or through Nova Preview.

    Version: 2.3.0
    License: MIT
    Platform: macOS
    Editor: Panic Nova

    Features

    Jupyter Notebook Studio

    Notebook Studio provides a local, interactive interface for working with .ipynb notebooks.

    Python execution

    • Individual Python code-cell execution
    • Run All Cells
    • Cell output display
    • Notebook saving
    • Kernel selection
    • Kernel interruption
    • Kernel restart
    • Standard Jupyter notebook support

    Python debugging

    • Individual code-cell debugging
    • Breakpoint creation
    • Breakpoint verification
    • Execution-line highlighting
    • Floating debugger toolbar
    • Variable inspection
    • Breakpoint-management controls
    • Continue execution
    • Pause
    • Step Over
    • Step Into
    • Step Out
    • Stop debugging

    Python debugging requires a compatible Jupyter kernel.

    Some advanced debugging scenarios, particularly cross-cell debugging and source mapping, require further testing.

    Notebook interface

    • Python code cells
    • SQL cells
    • Markdown cells
    • Raw cells
    • Add cells above or below existing cells
    • Move cells
    • Delete cells
    • Notebook sidebar
    • Debugger sidebar
    • Floating debugger controls
    • Clear Outputs
    • Save notebooks as .ipynb files

    Local MySQL SQL Integration

    Version 2.3.0 adds SQL execution inside Notebook Studio.

    Features include:

    • SQL cells alongside Python cells
    • SQL cell insertion controls
    • Local MySQL query execution
    • SQL results displayed in the notebook interface
    • SQL execution cancellation
    • Integration with an existing MySQL installation
    • Use of MySQL client login-path configuration

    The SQL executor uses the local MySQL command-line client.

    The current implementation is configured around the MySQL client at:

    /usr/local/mysql/bin/mysql

    The executor uses a MySQL login path named:

    nova

    Users may need to adjust the local MySQL configuration or source code for their own installations.

    Important: SQL execution is not equivalent to a full MySQL debugger.

    The extension does not currently provide complete SQL statement-level debugging with breakpoints, step-through execution, and stored-routine variable inspection.

    The SQL backend requires additional testing across different MySQL installations and configurations.

    Official JupyterLab

    Nova Jupyter Bridge also supports the official JupyterLab interface.

    Features include:

    • Launching JupyterLab directly from Nova
    • Opening existing .ipynb notebooks
    • Native JupyterLab notebook editing
    • Native JupyterLab execution
    • JupyterLab debugging with compatible kernels
    • Rich notebook outputs
    • Notebook file management
    • Browser and Nova Preview opening options

    JupyterLab must already be installed in the configured Python environment.

    The extension does not automatically install it.

    Note: Notebook Studio's custom floating debugger toolbar is separate from JupyterLab's native debugging interface.

    Open in Browser or Nova Preview

    Version 2.3.0 introduces an opening dialog for both Notebook Studio and JupyterLab.

    When an interface is ready, choose:

    Open in Browser

    Opens the authenticated notebook in your default web browser.

    If Safari is configured as your default browser, the notebook opens in Safari.

    Open in Nova Preview

    Attempts to open the notebook inside Nova Preview.

    If automatic Preview navigation is unavailable, the extension copies the authenticated local URL and provides manual instructions.

    Cancel

    Dismisses the opening dialog without shutting down the notebook server.

    Automatic Preview navigation

    Automatic navigation uses optional macOS System Events and Accessibility automation.

    Depending on your macOS permissions and Nova version, automatic navigation may not succeed.

    You can still open the notebook by pasting the copied URL into Nova Preview.

    Nova Task Integration

    The extension provides two independent Nova tasks:

    1. Jupyter Notebook Studio
    2. JupyterLab

    Both tasks support Nova's Run and Build actions.

    A separate build step is not required before launching a notebook.

    The extension also provides commands through Nova's Extensions menu.

    Privacy and Security

    Nova Jupyter Bridge is designed for local development and minimal data collection.

    The extension:

    • Contains no advertising SDK
    • Contains no analytics integration
    • Contains no intentional telemetry
    • Requires no extension-specific online account
    • Runs its managed notebook servers locally
    • Restricts managed notebook servers to 127.0.0.1
    • Uses authentication for local notebook access
    • Does not automatically upload notebook contents to an extension-operated service
    • Does not automatically install Python packages
    • Does not automatically create Python environments
    • Does not embed MySQL passwords in its source code
    • Is distributed under the MIT License

    Authentication

    Notebook Studio and JupyterLab use authenticated local URLs.

    These URLs must be treated as sensitive because anyone who obtains a valid URL may be able to access the corresponding local notebook server.

    The extension may copy an authenticated URL to the macOS clipboard for opening in Nova Preview.

    Avoid sharing authentication tokens, private notebook URLs, passwords, or confidential notebook contents.

    Security limitations

    This extension has not undergone an independent third-party security audit.

    Python code and SQL queries execute with the privileges available to their respective local environments and database accounts.

    Additional Jupyter packages, kernels, and extensions may introduce their own security or network behavior.

    Requirements

    • macOS
    • Panic Nova
    • An existing Python installation
    • jupyter_client
    • ipykernel
    • JupyterLab for the official JupyterLab interface
    • A compatible debugging kernel for Python debugging

    For SQL functionality:

    • MySQL Server
    • MySQL command-line client
    • A configured MySQL login path
    • Appropriate database permissions

    Dependencies must be installed separately.

    Nova Jupyter Bridge does not automatically install packages or create environments.

    Installation

    Nova Extension Library

    Once the extension is accepted into Nova's Extension Library:

    1. Open Nova.
    2. Open the Extension Library.
    3. Search for Nova Jupyter Bridge.
    4. Install the extension.
    5. Open your coding project.
    6. Configure the Python executable if necessary.

    Manual installation

    The source code is available on GitHub:

    https://github.com/utkarsh-data-enthusiast/nova-jupyter-bridge

    Download the extension bundle and install it through Nova.

    Development installation

    To test the source directly:

    1. Open the .novaextension development project in Nova.
    2. Select Extensions → Activate Project as Extension.
    3. Open your coding project.
    4. Select the Notebook Studio or JupyterLab task.

    Configuration

    Open your project's Nova extension settings and select Nova Jupyter Bridge.

    Python executable

    Configuration key:

    jupyterbridge.python

    Specify an existing Python executable containing the required Jupyter packages.

    Example:

    /Library/Frameworks/Python.framework/Versions/3.14/bin/python3.14

    This path is an example and may differ between installations.

    The configured Python executable launches both Notebook Studio and JupyterLab.

    The notebook's execution kernel can use another registered Python environment.

    For example, a JupyterLab server may run under one Python installation while a notebook kernel uses Python 3.12 for compatible machine-learning packages.

    Notebook Studio kernel override

    Configuration key:

    jupyterbridge.kernelOverride

    Optionally specify an installed Jupyter kernel.

    Leave this setting empty to use the notebook's configured kernel.

    Automatic Nova Preview navigation

    Configuration key:

    jupyterbridge.autoPreview

    When enabled, the extension attempts automatic navigation after you select Open in Nova Preview.

    When disabled, you can still open the notebook manually using the authenticated URL.

    Usage

    Open Notebook Studio

    1. Open a Nova project.
    2. Open or select an .ipynb notebook.
    3. Select the Jupyter Notebook Studio task.
    4. Click Run.
    5. Choose Open in Browser or Open in Nova Preview.

    Run Python code

    Each Python code cell has a Run button.

    Click Run to execute the selected cell.

    Use Run All to execute the notebook's code cells.

    Debug Python code

    1. Open Notebook Studio.
    2. Select a Python code cell.
    3. Set a breakpoint beside the required line.
    4. Click the cell's Debug button.
    5. Use the floating debugger toolbar.

    Available debugging operations include Continue, Pause, Step Over, Step Into, Step Out, and Stop.

    The exact debugging capabilities depend on the selected kernel.

    Execute SQL

    1. Open Notebook Studio.
    2. Add an SQL cell.
    3. Enter a MySQL query.
    4. Run the SQL cell.
    5. Inspect the returned output.

    SQL execution requires a working MySQL client and login-path configuration.

    Open JupyterLab

    1. Open a Nova project.
    2. Open or select an .ipynb notebook.
    3. Select the JupyterLab task.
    4. Click Run.
    5. Choose the desired opening option.

    Notebook Studio and JupyterLab can access the same notebook files, but they do not automatically share live kernel sessions.

    Avoid simultaneously editing the same notebook in both interfaces without coordinating saves and reloads.

    Project Structure

    nova-jupyter-bridge.novaextension/
│
├── Assets/
│   ├── app.css
│   ├── app.js
│   └── index.html
│
├── Scripts/
│   ├── main.js
│   ├── mysql_executor.py
│   ├── server.py
│   └── server_core.py
│
├── .gitignore
├── CHANGELOG.md
├── LICENSE
├── README.md
├── extension.json
├── extension.png
└── extension@2x.png

    Source components

    Scripts/main.js

    Registers Nova commands and tasks, launches the notebook interfaces, manages local JupyterLab processes, and provides browser/Preview opening options.

    Scripts/server.py

    Provides the Notebook Studio server entry point and integration with additional backend functionality.

    Scripts/server_core.py

    Contains the core Notebook Studio server implementation.

    Scripts/mysql_executor.py

    Provides local MySQL execution support.

    Assets/app.js

    Implements the interactive Notebook Studio frontend.

    Assets/app.css

    Defines Notebook Studio styling.

    Assets/index.html

    Defines the Notebook Studio HTML entry point.

    Known Limitations

    • Automatic Nova Preview navigation is dependent on macOS permissions and Nova's interface.
    • Advanced Python debugging requires additional testing.
    • SQL execution is not a complete SQL debugger.
    • MySQL client configuration may require manual setup.
    • Notebook Studio and JupyterLab do not share live kernel sessions automatically.
    • External Jupyter servers are not supported by the current launcher.
    • The extension does not automatically install dependencies.
    • Some SQL and debugger workflows require further end-to-end testing.

    Roadmap

    Potential future improvements include:

    • Improved cross-cell Python debugging
    • More reliable debugger state management
    • Improved execution-line tracking
    • Expanded SQL functionality
    • Improved kernel recovery
    • Additional automated tests
    • Improved accessibility
    • Further privacy and security hardening

    Roadmap items are not guaranteed features.

    Development and Contributions

    Contributions, bug reports, and suggestions are welcome.

    Repository:

    https://github.com/utkarsh-data-enthusiast/nova-jupyter-bridge

    Bug reports:

    https://github.com/utkarsh-data-enthusiast/nova-jupyter-bridge/issues

    When reporting a bug, include the relevant Nova, macOS, Python, and JupyterLab versions, along with steps to reproduce.

    Do not include passwords, authentication tokens, private notebook URLs, or confidential notebook contents.

    License

    Nova Jupyter Bridge is distributed under the MIT License.

    Copyright (c) 2026 PatriotEver Lab.

    See LICENSE for the complete license.

    Author

    PatriotEver Lab

    GitHub:

    https://github.com/utkarsh-data-enthusiast

    Nova Jupyter Bridge — Open Source. Local Development. Privacy by Design.

    Release Notes

    Changelog

    All notable changes to Nova Jupyter Bridge are documented here.

    Nova Jupyter Bridge is developed by PatriotEver Lab and
    distributed under the MIT License.

    This changelog follows the principles of
    Keep a Changelog
    and Semantic Versioning.

    [Unreleased]

    Planned

    • Improve debugger reliability across different Jupyter kernels.
    • Refine execution-line highlighting during step-by-step debugging.
    • Improve debugging of functions defined in other notebook cells.
    • Improve breakpoint verification and source mapping.
    • Improve kernel interruption, recovery, and restart behavior.
    • Expand automated testing.
    • Improve accessibility and keyboard navigation.
    • Continue privacy and security reviews.

    Planned features are subject to change.

    [2.3.0] - 2026-10-17

    Added

    SQL Integration

    • Added SQL cell support to Nova Notebook Studio.
    • Added controls for inserting SQL cells above and below existing cells.
    • Added SQL cell creation from the notebook interface.
    • Added a local MySQL execution backend.
    • Added SQL query execution using the existing MySQL command-line client.
    • Added SQL output display inside Notebook Studio.
    • Added support for cancelling SQL execution.
    • Added support for using an existing MySQL login-path configuration.
    • Preserved the ability to work with Python and SQL cells in the
      same notebook interface.

    JupyterLab Improvements

    • Improved launching of official JupyterLab from Nova.
    • Improved selection and opening of existing Jupyter notebooks.
    • Improved handling of local JupyterLab server ports.
    • Improved detection of authenticated JupyterLab startup URLs.
    • Preserved separate JupyterLab and Notebook Studio tasks.
    • Preserved support for Nova Run and Build actions.

    Browser and Preview Options

    • Added an opening dialog for Notebook Studio and JupyterLab.
    • Added an Open in Browser option.
    • Added an Open in Nova Preview option.
    • Added a Cancel option that leaves the server running.
    • Added support for opening authenticated notebook URLs using
      the system's default browser.
    • Preserved automatic Nova Preview navigation when supported.
    • Preserved manual Preview navigation using copied local URLs.
    • Improved fallback messages when automatic Preview navigation fails.

    Debugger Interface

    • Expanded Notebook Studio debugger controls.
    • Added or refined controls for inspecting variables.
    • Added or refined breakpoint-management controls.
    • Added additional kernel-management controls.
    • Preserved the floating debugger toolbar.
    • Preserved Python breakpoint and step-through debugging support.
    • Preserved per-cell Run and Debug actions.

    Changed

    Notebook Studio

    • Updated the notebook interface to accommodate SQL cells.
    • Updated cell controls for Python and SQL workflows.
    • Improved communication between the notebook frontend and
      local execution services.
    • Preserved standard Jupyter notebook compatibility.

    Extension Architecture

    • Updated Scripts/main.js for JupyterLab startup and opening options.
    • Separated the original notebook server implementation into
      Scripts/server_core.py.
    • Updated Scripts/server.py to integrate additional server functionality.
    • Added Scripts/mysql_executor.py for local MySQL execution.
    • Updated Assets/app.js for SQL integration and interface improvements.
    • Added .gitignore to exclude local configuration and temporary files.

    Privacy and Security

    • Preserved local-only notebook server operation.
    • Preserved authenticated notebook access.
    • Preserved loopback binding to 127.0.0.1.
    • Continued using existing Python installations.
    • Avoided automatic creation of Python environments.
    • Avoided storing MySQL passwords in the extension source.
    • Preserved the no-telemetry design.
    • Preserved the MIT License.

    Fixed

    • Addressed JupyterLab startup issues associated with port selection.
    • Improved handling of authenticated JupyterLab URLs.
    • Restored missing extension launcher functions.
    • Improved browser and Preview opening workflows.
    • Improved handling of automatic Preview navigation failures.

    Known Limitations

    • Automatic Nova Preview navigation depends on macOS permissions
      and Nova's interface.
    • SQL execution does not provide a complete MySQL statement-level
      debugger with breakpoints and variable inspection.
    • Python debugging requires a compatible Jupyter kernel.
    • Notebook Studio and JupyterLab do not automatically share
      the same live kernel session.
    • Some advanced cross-cell debugging scenarios require further testing.
    • SQL execution and cancellation require further testing across
      different MySQL versions and configurations.

    Release Notes

    Version 2.3.0 expands Nova Jupyter Bridge with local SQL execution,
    additional notebook controls, and improved JupyterLab integration.

    Users can choose to open Notebook Studio or JupyterLab in their
    default browser or inside Nova Preview.

    The extension remains open source, privacy-focused, and free
    of advertising and telemetry.

    [2.2.0] - 2026-10-16

    Added

    Two Independent Jupyter Interfaces

    • Added Jupyter Notebook Studio as a Nova task.
    • Added JupyterLab as a separate Nova task.
    • Added Run and Build actions for both tasks.
    • Added commands for opening and stopping JupyterLab.
    • Added a command for copying the JupyterLab Preview URL.
    • Added support for launching JupyterLab using the configured
      Python executable.
    • Added support for opening a selected .ipynb notebook in JupyterLab.

    Debugger Improvements

    • Added backend tracking of the debugger's current execution location.
    • Added execution-line information to the Notebook Studio state API.
    • Added frontend support for highlighting the currently paused
      Python statement.
    • Added separate visual elements for breakpoint markers and line numbers.
    • Added source mapping for debugging notebook cells.
    • Added breakpoint verification status reporting.
    • Added debugger state and pause revision tracking.

    Debugger Controls

    Added or refined support for:

    • Continue
    • Pause
    • Step Over
    • Step Into
    • Step Out
    • Stop

    Additional improvements:

    • Updated the floating debugger toolbar's state handling.
    • Improved debugger button availability based on execution state.
    • Added backend support for stopping debugging through a
      dedicated endpoint.

    Kernel Management

    • Updated Python kernel interruption handling.
    • Added recovery logic for unresponsive debugging sessions.
    • Improved kernel restart handling.
    • Added frontend status reporting during kernel recovery.
    • Improved handling of execution sessions invalidated by a kernel restart.

    Notebook Management

    • Added persistent clearing of notebook outputs.
    • Added execution-count resetting when clearing outputs.
    • Improved synchronization between notebook outputs and the frontend.
    • Improved sequential execution handling for Run All.
    • Improved notebook cell management.
    • Preserved standard .ipynb notebook compatibility.

    Changed

    Notebook Studio Interface

    • Updated the notebook editor to support execution-line highlighting.
    • Updated breakpoint positioning so markers appear beside line numbers.
    • Preserved the full-width notebook editor.
    • Preserved independently collapsible Notebook and Debugger sidebars.
    • Preserved the floating debugger toolbar.
    • Improved responsive interface styling.
    • Improved accessibility labels for notebook and debugger controls.

    Nova Integration

    • Updated the task assistant to expose both Jupyter interfaces.
    • Updated the extension manifest to include JupyterLab commands.
    • Updated extension configuration descriptions.
    • Preserved optional automatic Nova Preview navigation.
    • Preserved manual Preview navigation as a fallback.

    Privacy and Security

    • Preserved local-only server binding to 127.0.0.1.
    • Preserved authentication for notebook interfaces.
    • Preserved the existing no-telemetry design.
    • Continued using the user's configured Python environment.
    • Avoided automatic dependency installation.
    • Preserved the MIT License.

    Fixed

    • Corrected AppleScript comment syntax in automatic Preview navigation.
    • Updated frontend and backend communication for debugger location tracking.
    • Updated breakpoint marker rendering to avoid replacing line-number text.
    • Updated the Clear Outputs workflow to persist changes in the notebook file.

    Known Limitations

    • Advanced cross-cell debugging requires further testing.
    • Execution-line highlighting may require additional refinements.
    • Automatic Nova Preview navigation depends on macOS permissions
      and Nova's interface.
    • JupyterLab debugging requires a compatible kernel.
    • Notebook Studio and JupyterLab do not automatically share
      live kernel sessions.
    • Some debugger recovery scenarios may require further improvements.

    Release status: Not every feature has undergone comprehensive
    end-to-end testing.

    [2.1.0] - Previous Development Version

    Available Features

    The previous Notebook Studio implementation included:

    • Local Jupyter notebook execution.
    • Individual code-cell Run and Debug buttons.
    • Python breakpoint support.
    • Kernel selection.
    • Kernel interruption and restart.
    • Notebook saving.
    • Notebook cell management.
    • Markdown and raw cells.
    • Notebook outline sidebar.
    • Debugger sidebar.
    • Floating debugger toolbar.
    • Local authentication.
    • Optional Nova Preview automation.

    Version 2.1.0 served as the development baseline for the improvements
    introduced in version 2.2.0.

    A complete historical change-by-change record for this earlier
    development version is not available.

    License

    Copyright (c) 2026 PatriotEver Lab.

    Licensed under the MIT License.

    See LICENSE for the complete license text.

    Repository

    Nova Jupyter Bridge

    https://github.com/utkarsh-data-enthusiast/nova-jupyter-bridge

    Bug Reports

    https://github.com/utkarsh-data-enthusiast/nova-jupyter-bridge/issues

    License

    MIT License

    Copyright (c) 2026 PatriotEver Lab

    Permission is hereby granted, free of charge, to any person obtaining a copy
    of this software and associated documentation files (the "Software"), to deal
    in the Software without restriction, including without limitation the rights
    to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
    copies of the Software, and to permit persons to whom the Software is
    furnished to do so, subject to the following conditions:

    The above copyright notice and this permission notice shall be included in all
    copies or substantial portions of the Software.

    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
    AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
    OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
    SOFTWARE.