wisp-vpn 0.1.0__py3-none-any.whl

wisp/cli/__init__.py

@@ -0,0 +1,3 @@
+from wisp.cli.app import WispApp
+
+__all__ = ["WispApp"]

wisp/cli/__main__.py

@@ -0,0 +1,10 @@
+from wisp.cli.app import WispApp
+
+
+def main() -> None:
+    app = WispApp()
+    app.run()
+
+
+if __name__ == "__main__":
+    main()

wisp/cli/app.py

@@ -0,0 +1,252 @@
+"""Root Textual application and global styles for the Wisp TUI."""
+
+from textual.app import App
+from textual.binding import Binding
+
+from wisp.cli.screens import ConfigScreen, DeployScreen, MainMenuScreen
+from wisp.cli.screens.modal import ConfirmDestroyScreen
+from wisp.cli.screens.shutdown import confirmed_destroy
+from wisp.cli.state import AppState
+from wisp.session import (
+    find_orphaned_session,
+    install_signal_handlers,
+    register_atexit,
+)
+
+
+class WispApp(App):
+    """The Wisp terminal UI application.
+
+    Owns the shared :class:`~wisp.cli.state.AppState`, defines global CSS and
+    key bindings, and installs the main-menu, config, and deploy screens on
+    mount.
+    """
+
+    TITLE = "Wisp"
+    SUB_TITLE = "Ephemeral WireGuard VPNs on your own cloud"
+
+    BINDINGS = [
+        Binding("q", "quit", "Exit", show=True),
+        Binding("ctrl+c", "quit", "Exit", show=False),
+    ]
+
+    CSS = """
+    Screen {
+        background: #0b0f19;
+        color: #f1f5f9;
+        align: center middle;
+    }
+
+    Header {
+        background: #111827;
+        color: #38bdf8;
+        dock: top;
+        height: 1;
+    }
+
+    Footer {
+        background: #111827;
+        dock: bottom;
+        height: 1;
+    }
+
+    .card {
+        background: #1e293b;
+        border: round #38bdf8;
+        padding: 1 2;
+        width: 74;
+        height: auto;
+        /* Must stay at 100%: any smaller percentage truncates the auto height
+           by a row or two, and `overflow-y: auto` then renders a scrollbar for
+           that gap alone -- a scroll that reveals nothing but padding. At 100%
+           the bar disappears once the content fits and still appears when the
+           terminal is genuinely too short to show everything. */
+        max-height: 100%;
+        overflow-y: auto;
+    }
+
+    .title {
+        text-style: bold;
+        color: #38bdf8;
+        text-align: center;
+        margin-bottom: 1;
+    }
+
+    .subtitle {
+        color: #94a3b8;
+        text-align: center;
+        margin-bottom: 1;
+    }
+
+    .btn-primary {
+        background: #0284c7;
+        color: #ffffff;
+        border: none;
+        width: 100%;
+        margin-top: 1;
+    }
+
+    .btn-primary:hover {
+        background: #0369a1;
+    }
+
+    .btn-secondary {
+        background: #334155;
+        color: #f8fafc;
+        border: none;
+        width: 100%;
+        margin-top: 1;
+    }
+
+    .btn-secondary:hover {
+        background: #475569;
+    }
+
+    .btn-danger {
+        background: #dc2626;
+        color: #ffffff;
+        border: none;
+        width: 100%;
+        margin-top: 1;
+    }
+
+    .btn-danger:hover {
+        background: #b91c1c;
+    }
+
+    Input:focus, Switch:focus {
+        border: tall #38bdf8;
+    }
+
+    Button:focus {
+        text-style: bold reverse;
+    }
+    """
+
+    def __init__(self) -> None:
+        super().__init__()
+        self.state = AppState()
+
+    def on_mount(self) -> None:
+        """Install the app screens and show the main menu."""
+        try:
+            from wisp.config.settings import describe_config_sources
+            from wisp.utils import logger
+
+            logger.info(describe_config_sources())
+        except Exception:
+            pass  # purely informational; never block startup over this
+
+        self._configure_shutdown()
+
+        self.install_screen(MainMenuScreen(), name="main_menu")
+        self.install_screen(ConfigScreen(), name="config")
+        self.install_screen(DeployScreen(), name="deploy")
+        self.push_screen("main_menu")
+        self._offer_orphan_cleanup()
+
+    def thread_safe_call(self, message: str) -> None:
+        """Show a one-line status on whichever screen is active, from any thread.
+
+        Teardown runs on a worker thread long after the screen that started it was
+        swapped out, so it cannot hold a reference to it. Resolving the widget at
+        call time keeps the teardown tied to the app instead.
+
+        Args:
+            message (str): Status text to display.
+        """
+        if self._exit:
+            return
+        for widget_id in ("#shutdown-status", "#tunnel-health", "#progress-status-msg"):
+            for screen in self.screen_stack:
+                try:
+                    widget = screen.query_one(widget_id)
+                except Exception:
+                    continue
+                self.call_from_thread(widget.update, message)
+                return
+
+    def _configure_shutdown(self) -> None:
+        """Wire every shutdown trigger into the session guard.
+
+        Ctrl+C is deliberately *not* routed through a signal handler: Textual's
+        driver clears the terminal's ``ISIG`` flag, so Ctrl+C arrives as a key
+        event and lands on the ``ctrl+c`` binding below. Keeping it a key event
+        means the teardown runs through the same UI path as ``q``, with visible
+        progress, instead of interrupting the event loop from a signal context.
+
+        Signals sent from outside (a shell ``kill``, a supervisor, a closing
+        terminal) still have to be caught, so ``SIGINT``/``SIGTERM`` go to the
+        guard, and ``atexit`` covers normal interpreter exit on all platforms.
+        """
+        install_signal_handlers(self.state.session_guard)
+        register_atexit(self.state.session_guard)
+
+    def action_quit(self) -> None:
+        """Quit, destroying any live tunnel — asking first, unless disabled.
+
+        Reached by both ``q`` and ``Ctrl+C`` from every screen. When a tunnel is
+        up the session guard is armed and quitting destroys it, which is
+        irreversible, so the same ``ConfirmDestroyScreen`` as the destroy button
+        asks first (honouring ``[general] confirm_destroy``). Elsewhere there is
+        nothing live and the app quits straight away.
+        """
+        state = self.state
+        if isinstance(self.screen, ConfirmDestroyScreen):
+            return
+        if state.session_guard.armed and state.config.confirm_destroy:
+            self.push_screen(ConfirmDestroyScreen(), self._on_quit_destroy_choice)
+        else:
+            self.exit()
+
+    def _on_quit_destroy_choice(self, choice: tuple[bool, bool] | None) -> None:
+        """Apply the destroy modal's verdict when quitting with a live session."""
+        confirmed_destroy(
+            self,
+            choice,
+            "tunnel destroyed on quit",
+        )
+
+    def _offer_orphan_cleanup(self) -> None:
+        """Offer to clean up a session left behind by a previous run.
+
+        A crash, a ``kill -9`` or a power loss leave the marker file on disk.
+        Its owning process is gone, so its VM is still running and still
+        billing; this surfaces that instead of leaking it silently.
+        """
+        orphan = find_orphaned_session()
+        if orphan is None:
+            return
+
+        from wisp.utils import logger
+
+        logger.warning(
+            f"Found a session left behind by a dead process: {orphan.summary()}"
+        )
+        try:
+            self.notify(
+                f"Orphaned tunnel found: {orphan.summary()}.\n"
+                "Cloud resources may still be incurring charges; clean them up "
+                "using option 4 in the main menu.",
+                title="Orphaned session",
+                severity="warning",
+                timeout=15,
+            )
+        except Exception:
+            # Notifications are cosmetic; never let them block startup.
+            pass
+
+        # The notification alone expires, so the menu also carries a durable
+        # row for this: the warning is only useful while it can still be acted
+        # on, and the marker outlives the process that would have used it.
+        self.call_after_refresh(self._refresh_menu_orphan_row)
+
+    def _refresh_menu_orphan_row(self) -> None:
+        """Ask the main menu to re-evaluate its orphan-cleanup row."""
+        try:
+            menu = self.get_screen("main_menu")
+        except Exception:
+            return
+        refresher = getattr(menu, "refresh_orphan_row", None)
+        if callable(refresher):
+            refresher()

wisp/cli/screens/__init__.py

@@ -0,0 +1,15 @@
+from wisp.cli.screens.config import ConfigScreen
+from wisp.cli.screens.deploy import DeployScreen
+from wisp.cli.screens.main_menu import MainMenuScreen
+from wisp.cli.screens.progress import ProgressScreen
+from wisp.cli.screens.shutdown import ShutdownScreen
+from wisp.cli.screens.tunnel import TunnelScreen
+
+__all__ = [
+    "ConfigScreen",
+    "DeployScreen",
+    "MainMenuScreen",
+    "ProgressScreen",
+    "ShutdownScreen",
+    "TunnelScreen",
+]

wisp/cli/screens/base.py

@@ -0,0 +1,53 @@
+"""Shared base screen for the Wisp TUI.
+
+Textual only cycles focus with Tab/Shift+Tab by default. Wisp's screens are
+short forms, so arrow keys feel more natural: Up/Down move between widgets in
+DOM order (row by row), and Left/Right do the same, which is what most people
+try first inside a button group like *Iniciar despliegue / Cancelar*.
+
+``WispScreen`` adds that everywhere without touching widgets that already use
+the arrows for their own thing — an ``Input`` consumes ``left``/``right`` to
+move the text cursor, and a ``Select`` consumes ``up``/``down`` to move between
+its options. Textual resolves bindings from the focused widget upwards, so both
+already shadow these screen-level bindings while they are focused; the guard in
+``_arrows_owned_by_focused_widget`` makes the intent explicit and future-proof.
+
+All screens should inherit from this instead of ``textual.screen.Screen``.
+Textual merges ``BINDINGS`` across the MRO, so a subclass's own bindings
+(``escape``, ``1``/``2``/``3``, etc.) keep working unchanged.
+"""
+
+from textual.binding import Binding
+from textual.screen import Screen
+from textual.widgets import Input, Select
+
+
+class WispScreen(Screen):
+    """Base screen adding the arrow keys as focus navigation aliases."""
+
+    BINDINGS = [
+        Binding("left", "focus_previous_widget", "Anterior", show=False),
+        Binding("right", "focus_next_widget", "Siguiente", show=False),
+        Binding("down", "focus_next_widget", "Siguiente", show=False),
+        Binding("up", "focus_previous_widget", "Anterior", show=False),
+    ]
+
+    def action_focus_next_widget(self) -> None:
+        if self._arrows_owned_by_focused_widget():
+            return
+        self.focus_next()
+
+    def action_focus_previous_widget(self) -> None:
+        if self._arrows_owned_by_focused_widget():
+            return
+        self.focus_previous()
+
+    def _arrows_owned_by_focused_widget(self) -> bool:
+        """True when the focused widget needs the arrow keys for itself.
+
+        An ``Input`` uses ``left``/``right`` to move the text cursor and a
+        ``Select`` uses ``up``/``down`` to move between its own options (open
+        or not), so we back off and let them handle the arrows instead of
+        stealing focus mid-edit / mid-selection.
+        """
+        return isinstance(self.focused, (Input, Select))