dbctl 0.7.3__tar.gz → 0.7.4__tar.gz

{dbctl-0.7.3 → dbctl-0.7.4}/CHANGELOG.md

@@ -5,6 +5,51 @@ All notable changes to this project will be documented here.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/)
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.7.4] — 2026-08-10
+
+### Added
+
+- **`dbctl ui`** — an interactive [Textual](https://textual.textualize.io/)
+  TUI on top of the same connections/operations/tunnels/audit-log stack as
+  the CLI (`textual` is a base dependency, no separate install step). See
+  `docs/tui.md` for the full reference.
+  - **Connection tree** doubling as a lazily-loaded schema browser: `m`
+    toggles a simple `connection → table → column` view and a fuller
+    `connection → schema → Tables/Views → table/view → Columns/Indexes`
+    view; `g` toggles a flat list and a grouping that treats `-` as a path
+    separator (`in-gateway-ifp-dev` nests under `in-gateway` → `ifp`), with
+    single-child folders compressed and support for a name that's both a
+    group and a real connection at once (`ifp` / `ifp-gateway`). `c`/`d`/`t`
+    connect/disconnect/test-tunnel; `a`/`e` open `connections.yaml` in
+    `$EDITOR`.
+  - **Tabbed workspace**: a SQL editor (syntax-highlighted) or an
+    operation-launcher (a form built from a declared operation's
+    parameters) per tab, each with an independently resizable results
+    table and a status line (row count / rows-affected + duration) below
+    it. `Ctrl+N` new tab, `Ctrl+O` searchable operation launcher (type to
+    filter), `Ctrl+W` close, `Ctrl+R` run. Activating a table/view in the
+    tree opens a SQL tab pre-filled with a dialect-correct preview query
+    (`LIMIT` / `TOP` / `FETCH FIRST … ROWS ONLY`, with per-dialect
+    identifier quoting for mixed-case table/schema names).
+  - Connect/disconnect/test-tunnel and every SQL/operation run happen on a
+    background thread with a loading indicator, so the UI stays responsive
+    instead of freezing while a tunnel spins up or a query runs.
+  - Every run still respects `safety.read_only` / `safety.confirm` /
+    `allowed_operations` and is appended to `~/.dbctl/history.jsonl`,
+    exactly like a CLI-driven run.
+
+### Fixed
+
+- **`uv.lock` could resolve against a contributor's local package-index
+  override instead of public PyPI** — a machine-level `uv` config pointing
+  at an internal package mirror silently became the index every regenerated
+  `uv.lock` entry was resolved and hashed against, which both leaked an
+  internal hostname into the lock file and broke `uv sync --frozen` for
+  anyone (CI included) without access to that mirror. Pinned
+  `[[tool.uv.index]]` in `pyproject.toml` with `default = true` so this
+  project always locks against `pypi.org`/`files.pythonhosted.org`
+  regardless of what index a contributor's environment defaults to.
+
 ## [0.7.3] — 2026-08-04
 
 ### Added

{dbctl-0.7.3 → dbctl-0.7.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dbctl
-Version: 0.7.3
+Version: 0.7.4
 Summary: Generic CLI to monitor, control, and administer multiple databases via SSM, SSH, or direct connection.
 Author: dbctl contributors
 License: MIT
@@ -25,8 +25,10 @@ Requires-Dist: pyodbc>=5
 Requires-Dist: pyyaml>=6
 Requires-Dist: rich>=13
 Requires-Dist: sqlalchemy>=2
+Requires-Dist: textual>=0.60
 Provides-Extra: dev
 Requires-Dist: mypy>=1.10; extra == 'dev'
+Requires-Dist: pytest-asyncio>=0.24; extra == 'dev'
 Requires-Dist: pytest-cov>=5; extra == 'dev'
 Requires-Dist: pytest>=8; extra == 'dev'
 Requires-Dist: ruff>=0.5; extra == 'dev'
@@ -71,11 +73,13 @@ leaving the terminal.
 | DML is one `Ctrl-Enter` away                        | DML is **dry-run by default** until `--apply`; `--yes` skips the prompt |
 | No cross-DB diff                                     | `dbctl diff user-count prod-tenant1 int-tenant1`        |
 
-`dbctl` is **not** a schema browser or a query playground — it deliberately
-has no ad-hoc query command. Declaring operations in YAML keeps "what can be
-run against this DB" discoverable from a versioned file instead of buried in
-your shell history. (For ad-hoc exploration open the tunnel with
-`dbctl tunnel open <conn>` and point your favourite client at the local bind.)
+The declarative CLI above is still the primary interface: declaring
+operations in YAML keeps "what can be run against this DB" discoverable from
+a versioned file instead of buried in your shell history. For ad-hoc
+exploration, `dbctl ui` (see below) gives you a schema browser and a SQL
+editor without leaving `dbctl`'s tunnel/safety/audit model - or open the
+tunnel with `dbctl tunnel open <conn>` and point your favourite client at
+the local bind.
 
 ### How it reaches a database
 
@@ -352,6 +356,41 @@ reference.
 Secret-typed **operation** parameters (`type: secret`) are redacted in the
 audit log regardless of which DB password source the connection uses.
 
+## Interactive UI (`dbctl ui`)
+
+A [Textual](https://textual.textualize.io/) TUI for interactive work, on top
+of the same connections/operations/tunnels/audit-log stack as the CLI - not
+a separate code path with its own rules. `textual` is a base dependency, so
+no separate install step.
+
+```bash
+dbctl ui
+```
+
+- **Left pane**: a connection tree that doubles as a lazily-loaded schema
+  browser (`m` toggles a simple `connection → table → column` view and a
+  fuller `connection → schema → Tables/Views → table/view →
+  Columns/Indexes` view). Expanding a connection connects it if needed;
+  activating (Enter) a table/view opens a SQL tab pre-filled with a
+  dialect-correct preview query using the real table name. `g` toggles a
+  grouped view that treats `-` as a path separator (`in-gateway-ifp-dev`
+  nests under `in-gateway` → `ifp`) - handy once a fleet has more than a
+  handful of connections.
+- **Right pane**: a tabbed workspace of SQL editor / operation-launcher
+  tabs (`Ctrl+N` new tab, `Ctrl+O` searchable operation launcher, `Ctrl+W`
+  close, `Ctrl+R` run), each with an independently resizable results table
+  below it and a status line (row count / rows affected + duration) after
+  each run.
+- Connecting, disconnecting, testing a tunnel, and every SQL/operation run
+  happen on a background thread with a loading indicator, so the UI stays
+  responsive instead of freezing while a tunnel spins up or a query runs.
+- Every run still respects `safety.read_only` / `safety.confirm` /
+  `allowed_operations` and is appended to `~/.dbctl/history.jsonl`, exactly
+  like a CLI-driven run.
+
+See [`docs/tui.md`](docs/tui.md) for the full keybinding reference and
+per-dialect SQL details (row-limit clause, identifier quoting).
+
 ## Shell completion
 
 ```bash
@@ -375,6 +414,7 @@ dbctl/
 ├── docs/
 │   ├── connections.md      # connections.yaml reference
 │   ├── operations.md       # operations.yaml reference
+│   ├── tui.md              # dbctl ui reference (keybindings, dialect SQL)
 │   └── DESIGN.md           # architecture and design decisions
 └── dbctl/
     ├── cli.py              # dynamic groups + per-op Click commands
@@ -388,7 +428,21 @@ dbctl/
     ├── reports.py          # rich tables / json / csv / yaml + diff + copy/sync/validate rendering
     ├── audit.py            # history.jsonl
     ├── runtime.py          # opened_conn() ctx-mgr (tunnel+engine+healthcheck)
-    └── init.py             # dbctl init wizard
+    ├── init.py             # dbctl init wizard
+    └── ui/                 # Textual TUI (`dbctl ui`)
+        ├── app.py          # DbctlApp: connection tree + tabbed workspace
+        ├── session.py      # per-connection tunnel+engine kept open across tab-runs
+        ├── connection_tree.py  # lazy schema browser (simple/normal + flat/grouped views)
+        ├── grouping.py     # "-" as a path separator -> compressed connection-name trie
+        ├── schema.py       # sqlalchemy.inspect() wrapper for the tree
+        ├── editor_tab.py   # SQL editor tab
+        ├── operation_tab.py    # operation-launcher tab
+        ├── sql_templates.py    # dialect-aware default SELECT + identifier quoting
+        ├── screens.py      # confirm / new-tab / operation-launcher modal screens
+        ├── splitter.py     # draggable pane-resize bars
+        ├── tabs.py         # shared tab base: resize, toolbar, status bar, loading indicator
+        ├── results.py      # DataTable rendering helpers
+        └── registry.py     # tolerant connections/operations loading
 ```
 
 ## Development
@@ -397,7 +451,7 @@ dbctl/
 uv sync --extra dev
 make help            # list all Makefile targets
 make check           # lint + unit tests (the pre-commit gate)
-make test            # unit tests (~80 tests, in-memory SQLite, no docker)
+make test            # unit tests (~270 tests, sqlite-backed, no docker)
 make typecheck       # mypy strict (pre-existing debt; non-blocking)
 make smoke           # docker compose up + dbctl doctor against the fleet
 make build           # wheel + sdist via uv

{dbctl-0.7.3 → dbctl-0.7.4}/README.md

@@ -37,11 +37,13 @@ leaving the terminal.
 | DML is one `Ctrl-Enter` away                        | DML is **dry-run by default** until `--apply`; `--yes` skips the prompt |
 | No cross-DB diff                                     | `dbctl diff user-count prod-tenant1 int-tenant1`        |
 
-`dbctl` is **not** a schema browser or a query playground — it deliberately
-has no ad-hoc query command. Declaring operations in YAML keeps "what can be
-run against this DB" discoverable from a versioned file instead of buried in
-your shell history. (For ad-hoc exploration open the tunnel with
-`dbctl tunnel open <conn>` and point your favourite client at the local bind.)
+The declarative CLI above is still the primary interface: declaring
+operations in YAML keeps "what can be run against this DB" discoverable from
+a versioned file instead of buried in your shell history. For ad-hoc
+exploration, `dbctl ui` (see below) gives you a schema browser and a SQL
+editor without leaving `dbctl`'s tunnel/safety/audit model - or open the
+tunnel with `dbctl tunnel open <conn>` and point your favourite client at
+the local bind.
 
 ### How it reaches a database
 
@@ -318,6 +320,41 @@ reference.
 Secret-typed **operation** parameters (`type: secret`) are redacted in the
 audit log regardless of which DB password source the connection uses.
 
+## Interactive UI (`dbctl ui`)
+
+A [Textual](https://textual.textualize.io/) TUI for interactive work, on top
+of the same connections/operations/tunnels/audit-log stack as the CLI - not
+a separate code path with its own rules. `textual` is a base dependency, so
+no separate install step.
+
+```bash
+dbctl ui
+```
+
+- **Left pane**: a connection tree that doubles as a lazily-loaded schema
+  browser (`m` toggles a simple `connection → table → column` view and a
+  fuller `connection → schema → Tables/Views → table/view →
+  Columns/Indexes` view). Expanding a connection connects it if needed;
+  activating (Enter) a table/view opens a SQL tab pre-filled with a
+  dialect-correct preview query using the real table name. `g` toggles a
+  grouped view that treats `-` as a path separator (`in-gateway-ifp-dev`
+  nests under `in-gateway` → `ifp`) - handy once a fleet has more than a
+  handful of connections.
+- **Right pane**: a tabbed workspace of SQL editor / operation-launcher
+  tabs (`Ctrl+N` new tab, `Ctrl+O` searchable operation launcher, `Ctrl+W`
+  close, `Ctrl+R` run), each with an independently resizable results table
+  below it and a status line (row count / rows affected + duration) after
+  each run.
+- Connecting, disconnecting, testing a tunnel, and every SQL/operation run
+  happen on a background thread with a loading indicator, so the UI stays
+  responsive instead of freezing while a tunnel spins up or a query runs.
+- Every run still respects `safety.read_only` / `safety.confirm` /
+  `allowed_operations` and is appended to `~/.dbctl/history.jsonl`, exactly
+  like a CLI-driven run.
+
+See [`docs/tui.md`](docs/tui.md) for the full keybinding reference and
+per-dialect SQL details (row-limit clause, identifier quoting).
+
 ## Shell completion
 
 ```bash
@@ -341,6 +378,7 @@ dbctl/
 ├── docs/
 │   ├── connections.md      # connections.yaml reference
 │   ├── operations.md       # operations.yaml reference
+│   ├── tui.md              # dbctl ui reference (keybindings, dialect SQL)
 │   └── DESIGN.md           # architecture and design decisions
 └── dbctl/
     ├── cli.py              # dynamic groups + per-op Click commands
@@ -354,7 +392,21 @@ dbctl/
     ├── reports.py          # rich tables / json / csv / yaml + diff + copy/sync/validate rendering
     ├── audit.py            # history.jsonl
     ├── runtime.py          # opened_conn() ctx-mgr (tunnel+engine+healthcheck)
-    └── init.py             # dbctl init wizard
+    ├── init.py             # dbctl init wizard
+    └── ui/                 # Textual TUI (`dbctl ui`)
+        ├── app.py          # DbctlApp: connection tree + tabbed workspace
+        ├── session.py      # per-connection tunnel+engine kept open across tab-runs
+        ├── connection_tree.py  # lazy schema browser (simple/normal + flat/grouped views)
+        ├── grouping.py     # "-" as a path separator -> compressed connection-name trie
+        ├── schema.py       # sqlalchemy.inspect() wrapper for the tree
+        ├── editor_tab.py   # SQL editor tab
+        ├── operation_tab.py    # operation-launcher tab
+        ├── sql_templates.py    # dialect-aware default SELECT + identifier quoting
+        ├── screens.py      # confirm / new-tab / operation-launcher modal screens
+        ├── splitter.py     # draggable pane-resize bars
+        ├── tabs.py         # shared tab base: resize, toolbar, status bar, loading indicator
+        ├── results.py      # DataTable rendering helpers
+        └── registry.py     # tolerant connections/operations loading
 ```
 
 ## Development
@@ -363,7 +415,7 @@ dbctl/
 uv sync --extra dev
 make help            # list all Makefile targets
 make check           # lint + unit tests (the pre-commit gate)
-make test            # unit tests (~80 tests, in-memory SQLite, no docker)
+make test            # unit tests (~270 tests, sqlite-backed, no docker)
 make typecheck       # mypy strict (pre-existing debt; non-blocking)
 make smoke           # docker compose up + dbctl doctor against the fleet
 make build           # wheel + sdist via uv

{dbctl-0.7.3 → dbctl-0.7.4}/dbctl/cli.py

@@ -1020,7 +1020,7 @@ def _aliases(conns):
 
 def _root_list(ctx: click.Context) -> list[str]:
     conns, ops = registries(ctx)
-    static = ["connections", "operations", "status", "doctor", "init", "history", "tunnel"]
+    static = ["connections", "operations", "status", "doctor", "init", "history", "tunnel", "ui"]
     # multi-op operation-first top-level commands + deprecated verb-first groups
     multi_ops = {n for n, o in ops.items() if o.scope.value == "multi"}
     multi_modes = {o.mode.value for o in ops.values() if o.scope.value == "multi"}
@@ -1039,6 +1039,7 @@ def _root_get(ctx: click.Context, name: str):
         "init": init_cmd,
         "history": history_cmd,
         "tunnel": tunnel_cmd,
+        "ui": ui_cmd,
     }
     if name in static:
         return static[name]
@@ -1329,6 +1330,15 @@ def init_cmd(ctx):
     run_wizard(profile=ctx.obj.get("profile"))
 
 
+@click.command("ui")
+@click.pass_context
+def ui_cmd(ctx):
+    """Launch the interactive TUI: connection tree + tabbed SQL editor / operations."""
+    from dbctl.ui.app import DbctlApp
+
+    DbctlApp(profile=ctx.obj.get("profile")).run()
+
+
 @main.group("history")
 def history_cmd():
     """Show the audit log."""

{dbctl-0.7.3 → dbctl-0.7.4}/dbctl/db.py

@@ -60,7 +60,7 @@ def resolve_password(conn: Connection) -> str | None:
     raise DBError("no password source configured")
 
 
-def _driver_name(conn: Connection) -> str:
+def driver_name(conn: Connection) -> str:
     """Return the SQLAlchemy driver scheme for this connection.
 
     When the user provides a full ``url:`` string, the driver is the
@@ -79,7 +79,7 @@ def _driver_name(conn: Connection) -> str:
 def _connect_args(conn: Connection, timeout: float) -> dict:
     """Driver-specific connect-time knobs (mainly connect_timeout)."""
     args: dict = {}
-    driver = _driver_name(conn)
+    driver = driver_name(conn)
     if driver.startswith(("postgresql", "mysql", "mariadb", "oracle")):
         args["connect_timeout"] = int(max(1, timeout))
     # sqlite + duckdb are file-based — no connect_timeout; SQLAlchemy
@@ -111,7 +111,7 @@ def build_engine(conn: Connection, tunnel: Tunnel, *, echo: bool = False) -> Eng
 
     conn = resolve_connection(conn)
 
-    driver = _driver_name(conn)
+    driver = driver_name(conn)
     _check_driver_available(driver)
 
     from sqlalchemy import URL, make_url
@@ -264,4 +264,12 @@ def fmt_db_error(e: BaseException) -> str:
     return msg
 
 
-__all__ = ["build_engine", "resolve_password", "healthcheck", "DBError", "fmt_db_error", "text"]
+__all__ = [
+    "build_engine",
+    "resolve_password",
+    "healthcheck",
+    "DBError",
+    "fmt_db_error",
+    "driver_name",
+    "text",
+]

dbctl-0.7.4/dbctl/ui/__init__.py

@@ -0,0 +1,8 @@
+"""Interactive Textual UI for dbctl (`dbctl ui`).
+
+This package only *consumes* the existing loaders/executors
+(``dbctl.connections``, ``dbctl.operations``, ``dbctl.tunnels``, ``dbctl.db``,
+``dbctl.execute``, ``dbctl.audit``) - it does not change their behavior.
+"""
+
+from __future__ import annotations

dbctl-0.7.4/dbctl/ui/app.py

@@ -0,0 +1,234 @@
+"""``dbctl ui`` entry point.
+
+Composes a connection tree (left) with a tabbed workspace of SQL editor /
+operation-launcher tabs (right), each with a results table below. Reuses the
+same loaders/executors as the CLI - the only new state this module owns is
+the per-connection tunnel+engine lifecycle in ``dbctl.ui.session.SessionManager``.
+"""
+
+from __future__ import annotations
+
+import contextlib
+
+from textual import on
+from textual.app import App, ComposeResult
+from textual.containers import Horizontal
+from textual.css.query import NoMatches
+from textual.reactive import reactive
+from textual.widgets import Footer, Header, TabbedContent, TabPane
+
+from dbctl.ui.connection_tree import ConnectionActivated, ConnectionTree, TableActivated
+from dbctl.ui.editor_tab import SqlEditorPane
+from dbctl.ui.operation_tab import OperationPane
+from dbctl.ui.registry import load_registries
+from dbctl.ui.screens import NewTabScreen, OperationLauncherScreen
+from dbctl.ui.session import SessionManager
+from dbctl.ui.splitter import VerticalSplitter
+from dbctl.ui.sql_templates import default_select, qualified_table
+from dbctl.ui.tabs import EDITOR_HEIGHT_STEP, MAX_EDITOR_HEIGHT, MIN_EDITOR_HEIGHT, RunnableTab
+
+MIN_TREE_WIDTH = 20
+MAX_TREE_WIDTH = 80
+DEFAULT_TREE_WIDTH = 32
+TREE_WIDTH_STEP = 4
+
+
+class DbctlApp(App[None]):
+    """dbctl's interactive TUI: connection tree + tabbed SQL/operation workspace."""
+
+    TITLE = "dbctl"
+
+    CSS = """
+    #connection-tree {
+        border-right: solid $panel;
+    }
+    .pane-header {
+        padding: 0 1;
+        background: $panel;
+    }
+    .pane-toolbar {
+        height: auto;
+        padding: 0 1;
+    }
+    .param-row {
+        height: auto;
+        padding: 0 1;
+    }
+    .param-row Label {
+        width: 20;
+        content-align: right middle;
+    }
+    #sql-input, #param-form {
+        height: 1fr;
+    }
+    #results-table {
+        height: 1fr;
+    }
+    #run-loading {
+        height: 1fr;
+    }
+    #status-bar {
+        height: auto;
+        padding: 0 1;
+        background: $panel;
+        color: $text-muted;
+    }
+    #confirm-dialog, #new-tab-dialog, #operation-launcher-dialog {
+        width: 60;
+        height: auto;
+        padding: 1 2;
+        background: $panel;
+        border: thick $primary;
+    }
+    """
+
+    BINDINGS = [
+        ("ctrl+r", "run_tab", "Run"),
+        ("ctrl+n", "new_tab", "New tab"),
+        ("ctrl+w", "close_tab", "Close tab"),
+        ("ctrl+o", "launch_operation", "Run operation"),
+        ("ctrl+left", "narrow_tree", "Narrow tree"),
+        ("ctrl+right", "widen_tree", "Widen tree"),
+        ("ctrl+up", "grow_editor", "Grow editor"),
+        ("ctrl+down", "shrink_editor", "Shrink editor"),
+    ]
+
+    tree_width: reactive[int] = reactive(DEFAULT_TREE_WIDTH)
+
+    def __init__(self, profile: str | None = None) -> None:
+        super().__init__()
+        self.profile = profile
+        self.connections, self.operations, self._load_warnings = load_registries(profile)
+        self.sessions = SessionManager(self.connections)
+        self._tab_seq = 0
+
+    def compose(self) -> ComposeResult:
+        yield Header()
+        with Horizontal():
+            yield ConnectionTree(self.connections, self.sessions, profile=self.profile, id="connection-tree")
+            yield VerticalSplitter(min_value=MIN_TREE_WIDTH, max_value=MAX_TREE_WIDTH, id="tree-splitter")
+            yield TabbedContent(id="workspace")
+        yield Footer()
+
+    def on_mount(self) -> None:
+        for warning in self._load_warnings:
+            self.notify(warning, severity="warning", timeout=10)
+
+    def watch_tree_width(self, width: int) -> None:
+        with contextlib.suppress(NoMatches):  # not mounted yet - re-fires once it is
+            self.query_one("#connection-tree").styles.width = width
+
+    def action_narrow_tree(self) -> None:
+        self.tree_width = max(MIN_TREE_WIDTH, self.tree_width - TREE_WIDTH_STEP)
+
+    def action_widen_tree(self) -> None:
+        self.tree_width = min(MAX_TREE_WIDTH, self.tree_width + TREE_WIDTH_STEP)
+
+    def on_unmount(self) -> None:
+        self.sessions.disconnect_all()
+
+    @on(ConnectionActivated)
+    def _open_default_tab(self, message: ConnectionActivated) -> None:
+        self.open_sql_tab(message.name)
+
+    @on(TableActivated)
+    def _open_table_tab(self, message: TableActivated) -> None:
+        conn = self.connections[message.conn_name]
+        target = qualified_table(conn, message.table, message.schema_name)
+        self.open_sql_tab(message.conn_name, sql=default_select(conn, target))
+
+    def _next_tab_id(self) -> str:
+        self._tab_seq += 1
+        return f"tab-{self._tab_seq}"
+
+    def open_sql_tab(self, conn_name: str, *, sql: str | None = None) -> None:
+        tabbed = self.query_one(TabbedContent)
+        tab_id = self._next_tab_id()
+        initial_sql = sql or default_select(self.connections[conn_name])
+        pane = SqlEditorPane(conn_name, self.sessions, initial_sql, self.profile, id=f"pane-{tab_id}")
+        tabbed.add_pane(TabPane(f"{conn_name}: sql", pane, id=tab_id))
+        tabbed.active = tab_id
+
+    def open_operation_tab(self, conn_name: str, op_name: str) -> None:
+        tabbed = self.query_one(TabbedContent)
+        tab_id = self._next_tab_id()
+        op = self.operations[op_name]
+        pane = OperationPane(conn_name, op_name, op, self.sessions, self.profile, id=f"pane-{tab_id}")
+        tabbed.add_pane(TabPane(f"{conn_name}: {op_name}", pane, id=tab_id))
+        tabbed.active = tab_id
+
+    def action_new_tab(self) -> None:
+        if not self.connections:
+            self.notify("no connections configured", severity="warning")
+            return
+
+        def handle(result: tuple[str, str, str | None] | None) -> None:
+            if result is None:
+                return
+            kind, conn_name, op_name = result
+            if kind == "sql":
+                self.open_sql_tab(conn_name)
+            elif op_name is not None:
+                self.open_operation_tab(conn_name, op_name)
+
+        singles = {n: o for n, o in self.operations.items() if o.scope.value == "single"}
+        self.push_screen(NewTabScreen(list(self.connections), singles), handle)
+
+    def action_close_tab(self) -> None:
+        tabbed = self.query_one(TabbedContent)
+        if tabbed.active:
+            tabbed.remove_pane(tabbed.active)
+
+    def _active_runnable(self) -> RunnableTab | None:
+        pane = self.query_one(TabbedContent).active_pane
+        if pane is None:
+            return None
+        try:
+            return pane.query_one(RunnableTab)
+        except NoMatches:
+            return None
+
+    def action_run_tab(self) -> None:
+        runnable = self._active_runnable()
+        if runnable is not None:
+            runnable.run_tab()
+
+    def action_grow_editor(self) -> None:
+        runnable = self._active_runnable()
+        if runnable is not None:
+            runnable.editor_height = min(MAX_EDITOR_HEIGHT, runnable.editor_height + EDITOR_HEIGHT_STEP)
+
+    def action_shrink_editor(self) -> None:
+        runnable = self._active_runnable()
+        if runnable is not None:
+            runnable.editor_height = max(MIN_EDITOR_HEIGHT, runnable.editor_height - EDITOR_HEIGHT_STEP)
+
+    def _resolve_launch_connection(self) -> str | None:
+        """Pick the connection Ctrl+O should target: the active tab's
+        connection, else whatever's highlighted in the tree, else the only
+        connection if there's just one."""
+        runnable = self._active_runnable()
+        if runnable is not None:
+            return runnable.conn_name
+        name = self.query_one(ConnectionTree).connection_name_at_cursor()
+        if name:
+            return name
+        if len(self.connections) == 1:
+            return next(iter(self.connections))
+        return None
+
+    def action_launch_operation(self) -> None:
+        singles = {n: o for n, o in self.operations.items() if o.scope.value == "single"}
+        if not singles:
+            self.notify("no operations configured", severity="warning")
+            return
+        conn_name = self._resolve_launch_connection()
+        if conn_name is None:
+            self.notify("highlight a connection in the tree first", severity="warning")
+            return
+
+        def handle(op_name: str | None) -> None:
+            if op_name is not None:
+                self.open_operation_tab(conn_name, op_name)
+
+        self.push_screen(OperationLauncherScreen(singles, conn_name), handle)