command-gate 0.2.4__py3-none-any.whl

cgate/watch/queue.py

@@ -0,0 +1,106 @@
+"""Pure helpers for selecting the active batch, counting waiters, and healing it."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from cgate.db.commands import all_terminal
+from cgate.db.types import CommandStatus
+
+if TYPE_CHECKING:
+    from cgate.db.batches import BatchesRepo
+    from cgate.db.commands import CommandsRepo
+    from cgate.db.types import Batch, BatchId, Command
+
+
+def active_batch(batches: BatchesRepo) -> Batch | None:
+    """Return the next pending batch in FIFO order, or None."""
+    pending = batches.list_pending()
+    return pending[0] if pending else None
+
+
+def select_active_batch(pending: list[Batch], pinned_id: BatchId | None) -> Batch | None:
+    """Return the pinned batch if it's still pending, else the FIFO-oldest one.
+
+    Lets a human jump the queue and prioritize a specific batch instead
+    of being forced through strict FIFO order. Self-correcting: once the
+    pinned batch resolves (or otherwise drops out of `pending`), this
+    falls straight back to FIFO without needing the caller to notice and
+    clear the pin.
+    """
+    if pinned_id is not None:
+        for batch in pending:
+            if batch.id == pinned_id:
+                return batch
+    return pending[0] if pending else None
+
+
+def count_waiting(batches: BatchesRepo) -> int:
+    """Count batches queued behind the active one."""
+    return max(0, len(batches.list_pending()) - 1)
+
+
+def count_pending_commands(pending_batches: list[Batch], commands: CommandsRepo) -> int:
+    """Total PENDING commands across every batch still in the queue."""
+    return sum(
+        len(pending_commands_in_batch(commands.list_for_batch(batch.id)))
+        for batch in pending_batches
+    )
+
+
+def pending_commands_in_batch(commands_for_batch: list[Command]) -> list[Command]:
+    """Filter pending commands while preserving their repository order."""
+    return [
+        command
+        for command in commands_for_batch
+        if command.status is CommandStatus.PENDING
+    ]
+
+
+def is_batch_resolved(commands_for_batch: list[Command]) -> bool:
+    """Return whether every command in the batch has a terminal status."""
+    return all_terminal(commands_for_batch)
+
+
+def resolve_stale_batches(batches: BatchesRepo, commands: CommandsRepo) -> None:
+    """Stamp `resolved_at` on any pending batch whose commands are all terminal.
+
+    A command can turn terminal without going through the TUI's own
+    approve/reject path -- the MCP AUTO-mode auto-execution path is one
+    example. Whenever that happens the batch's `resolved_at` must be
+    stamped too, or it sits at the head of the FIFO queue forever with
+    nothing left to approve or reject, silently blocking every batch
+    behind it. This sweeps up any batch left in that state.
+    """
+    for batch in batches.list_pending():
+        commands_for_batch = commands.list_for_batch(batch.id)
+        if commands_for_batch and is_batch_resolved(commands_for_batch):
+            batches.mark_resolved(batch.id)
+
+
+def fail_orphaned_approvals(commands: CommandsRepo) -> None:
+    """Fail any command left `APPROVED` by a process that died mid-execution.
+
+    Approval runs synchronously end-to-end in one call: mark APPROVED, run
+    the command, stamp EXECUTED/FAILED. A command still APPROVED means that
+    call never got to finish -- it can never reach a terminal status on its
+    own, which keeps its batch stuck exactly like the `resolved_at` gap
+    `resolve_stale_batches` sweeps up.
+    """
+    for command in commands.list_by_status(CommandStatus.APPROVED):
+        _ = commands.update_status(
+            command.id,
+            status=CommandStatus.FAILED,
+            approved_by=command.approved_by,
+            result="interrupted before completion (cgate restarted mid-execution)",
+            expected_status=CommandStatus.APPROVED,
+        )
+
+
+def heal_queue(batches: BatchesRepo, commands: CommandsRepo) -> None:
+    """Repair queue state left inconsistent by a crash or a since-fixed bug.
+
+    Runs once when `cgate watch` starts, before the dashboard is shown.
+    """
+    fail_orphaned_approvals(commands)
+    resolve_stale_batches(batches, commands)

cgate/watch/render.py

@@ -0,0 +1,156 @@
+"""Pure markup helpers for the cgate watch TUI (spec §Colors in cgate watch)."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Final
+
+from rich.markup import escape as escape_markup
+
+from cgate.db.types import CommandStatus, ServerType
+from cgate.watch.theme import CGATE_THEME
+
+if TYPE_CHECKING:
+    from cgate.db.types import Batch, Command
+
+_RESULT_SNIPPET_MAX_CHARS: Final = 200
+
+# Rich markup can't reference Textual's $warning/$error/$success CSS
+# variables directly, so these pull the same hex values from CGATE_THEME
+# instead of hardcoding Rich's generic "yellow"/"red"/"green" names --
+# otherwise the two would drift apart the moment the theme's palette changes.
+_STATUS_GLYPHS: Final[dict[CommandStatus, str]] = {
+    CommandStatus.PENDING: f"[{CGATE_THEME.warning}]●[/{CGATE_THEME.warning}]",
+    CommandStatus.APPROVED: f"[{CGATE_THEME.warning}]◐[/{CGATE_THEME.warning}]",
+    CommandStatus.EXECUTED: f"[{CGATE_THEME.success}]✓[/{CGATE_THEME.success}]",
+    CommandStatus.REJECTED: f"[{CGATE_THEME.error}]✗[/{CGATE_THEME.error}]",
+    CommandStatus.FAILED: f"[{CGATE_THEME.error}]✗[/{CGATE_THEME.error}]",
+}
+
+
+def status_glyph(status: CommandStatus) -> str:
+    """Return the colored status symbol for one command."""
+    return _STATUS_GLYPHS[status]
+
+
+def server_badge(server_type: ServerType) -> str:
+    """Render a compact, colored server-type badge."""
+    match server_type:
+        case ServerType.WINDOWS:
+            return "[cyan]WIN[/cyan]"
+        case ServerType.LINUX:
+            return "[green]LNX[/green]"
+
+
+def approver_badge(approved_by: str | None) -> str:
+    """Render who or what approved a command.
+
+    ``mcp_server/tools.py`` prefixes auto-executed approvals with
+    ``auto:`` (see ``_auto_approve_by``) specifically so this can tell
+    them apart from a human's OS username at render time.
+    """
+    if not approved_by:
+        return ""
+    if approved_by.startswith("auto:"):
+        return " [cyan]⚙ auto[/cyan]"
+    return f" [green]👤 {escape_markup(approved_by)}[/green]"
+
+
+def risk_warning(risk_label: str | None) -> str:
+    """Render the high-blast-radius warning line, or an empty string when unflagged.
+
+    Shown regardless of PROPOSE/AUTO mode -- a human scanning the queue
+    should see it either way, not just when it happened to be the reason
+    AUTO mode queued the command instead of running it.
+    """
+    if not risk_label:
+        return ""
+    error = CGATE_THEME.error
+    return f"[bold {error}]⚠ RISKY:[/bold {error}] [{error}]{escape_markup(risk_label)}[/{error}]"
+
+
+def format_batch_header(batch: Batch) -> str:
+    """Render a bold, brand-colored title with an optional grey italic description below it."""
+    primary = CGATE_THEME.primary
+    lines = [f"[bold {primary}]{escape_markup(batch.title)}[/bold {primary}]"]
+    if batch.description:
+        lines.append(f"[grey50 italic]{escape_markup(batch.description)}[/grey50 italic]")
+    return "\n".join(lines)
+
+
+def format_queue_summary(*, pending_commands: int, waiting_batches: int) -> str:
+    """Render the always-on queue summary, or an empty string when it's empty.
+
+    Replaces the old "N batch(es) waiting" notice, which only ever
+    appeared once a *second* batch queued up -- with only one batch
+    pending (the common case) it showed nothing at all, even though
+    there could be several commands in it still needing a decision.
+    """
+    if pending_commands <= 0:
+        return ""
+    parts = [f"{pending_commands} pending command(s)"]
+    if waiting_batches > 0:
+        parts.append(f"{waiting_batches} batch(es) waiting")
+    warning = CGATE_THEME.warning
+    return f"[{warning}]▲ {' · '.join(parts)}[/{warning}]"
+
+
+def _result_snippet(result: str, *, max_chars: int = _RESULT_SNIPPET_MAX_CHARS) -> str:
+    """Trim a result blob to its first line, capped to a display-friendly length."""
+    stripped = result.strip()
+    if not stripped:
+        return ""
+    first_line = stripped.splitlines()[0]
+    if len(first_line) > max_chars:
+        return first_line[:max_chars] + "…"
+    return first_line
+
+
+def format_command_line(command: Command) -> str:
+    """Render one command row: status glyph, text, badges, reason, result snippet."""
+    glyph = status_glyph(command.status)
+    badge = server_badge(command.server_type)
+    line = (
+        f"{glyph} {escape_markup(command.command)}  {badge} "
+        f"[dim]{escape_markup(command.server_alias)}[/dim]"
+        f"{approver_badge(command.approved_by)}"
+    )
+    if command.risk_label:
+        line += f"\n    {risk_warning(command.risk_label)}"
+    if command.reason:
+        line += f"\n    [dim italic]↳ {escape_markup(command.reason)}[/dim italic]"
+    if command.status is CommandStatus.APPROVED:
+        line += "\n    [dim]⏳ running…[/dim]"
+    elif command.status is CommandStatus.EXECUTED and command.result:
+        line += f"\n    [dim]{escape_markup(_result_snippet(command.result))}[/dim]"
+    elif command.status is CommandStatus.FAILED and command.result:
+        error = CGATE_THEME.error
+        line += f"\n    [{error} dim]{escape_markup(_result_snippet(command.result))}[/{error} dim]"
+    return line
+
+
+def format_command_detail(command: Command) -> str:
+    """Render a command's full detail: status, server, reason, approver, full result.
+
+    Unlike `format_command_line`, the result is shown in full -- not
+    capped to `_RESULT_SNIPPET_MAX_CHARS` or truncated to one line.
+    """
+    server_line = (
+        f"[dim]{escape_markup(command.server_alias)}[/dim]  {server_badge(command.server_type)}"
+        f"  [dim]status: {command.status.value}[/dim]"
+    )
+    lines = [
+        f"{status_glyph(command.status)} [bold]{escape_markup(command.command)}[/bold]",
+        server_line,
+    ]
+    if command.risk_label:
+        lines.append(risk_warning(command.risk_label))
+    if command.reason:
+        lines.append(f"\n[italic]Reason:[/italic] {escape_markup(command.reason)}")
+    if command.approved_by:
+        lines.append(f"\n[italic]Approved by:[/italic]{approver_badge(command.approved_by)}")
+    if command.result:
+        stripped = command.result.strip()
+        if stripped:
+            lines.append("\n[bold]Result:[/bold]")
+            lines.append(escape_markup(stripped))
+    return "\n".join(lines)

cgate/watch/server_settings_modal.py

@@ -0,0 +1,179 @@
+"""Modal for editing per-server auto-approve opt-in flags (`s` key in cgate watch)."""
+
+from __future__ import annotations
+
+import getpass
+import sqlite3
+from typing import TYPE_CHECKING, ClassVar
+
+from textual.binding import Binding
+from textual.containers import Vertical
+from textual.screen import ModalScreen
+from textual.widgets import ListItem, ListView, Static
+from typing_extensions import override
+
+from cgate.db.mode import AppModeNotSetError, Mode
+from cgate.watch.mode_modal import mode_markup
+from cgate.watch.render import server_badge
+from cgate.watch.theme import CGATE_THEME
+
+if TYPE_CHECKING:
+    from textual.app import ComposeResult
+    from textual.binding import BindingType
+
+    from cgate.connections.store import ConnectionsRepo
+    from cgate.db.mode import AppModeRepo
+    from cgate.db.server_settings import ServerSettingsRepo
+    from cgate.db.types import Connection
+
+
+def _updated_by() -> str:
+    """Return the OS username for the audit column, falling back to 'unknown'."""
+    try:
+        return getpass.getuser() or "unknown"
+    except (KeyError, OSError):
+        return "unknown"
+
+
+def _row_markup(connection: Connection, *, auto_allowed: bool) -> str:
+    """Render one row: alias, server-type badge, and the auto-allowed checkbox."""
+    checkbox = "[✓]" if auto_allowed else "[ ]"
+    return f"{connection.alias}  {server_badge(connection.server_type)}  {checkbox}"
+
+
+class ServerRow(ListItem):
+    """One connection row in the settings list, carrying its alias for toggling."""
+
+    alias: str
+    _connection: Connection  # class-level annotation required by strict mode
+
+    def __init__(self, connection: Connection, *, auto_allowed: bool) -> None:
+        """Render the row and remember which connection it belongs to."""
+        super().__init__(Static(_row_markup(connection, auto_allowed=auto_allowed), markup=True))
+        self.alias = connection.alias
+        self._connection = connection
+
+    def set_auto_allowed(self, *, auto_allowed: bool) -> None:
+        """Re-render the row's checkbox for the new in-memory state."""
+        _ = self.query_one(Static).update(_row_markup(self._connection, auto_allowed=auto_allowed))
+
+
+class ServerSettingsModal(ModalScreen[bool]):
+    """Edit per-server auto-approve flags: Space toggles, Enter saves, Esc cancels.
+
+    Dismisses with ``True`` after a successful commit (even when nothing
+    changed); dismisses with ``False`` on Esc, with no writes at all.
+    """
+
+    CSS: ClassVar[str] = """
+    ServerSettingsModal { align: center middle; }
+    #settings-dialog {
+        width: 72;
+        height: auto;
+        max-height: 80%;
+        border: round $primary;
+        background: $surface;
+        padding: 1 2;
+    }
+    #settings-list { height: auto; max-height: 16; margin-top: 1; }
+    #settings-error { color: $error; }
+    """
+
+    # Priority bindings: checked before the focused ListView's own bindings,
+    # so Enter commits instead of triggering ListView's row-select.
+    BINDINGS: ClassVar[list[BindingType]] = [
+        Binding("space", "toggle_row", "Toggle", show=False, priority=True),
+        Binding("enter", "commit", "Save", show=False, priority=True),
+        Binding("escape", "cancel", "Cancel", show=False, priority=True),
+    ]
+
+    _connections: ConnectionsRepo  # class-level annotation required by strict mode
+    _settings: ServerSettingsRepo  # class-level annotation required by strict mode
+    _mode_repo: AppModeRepo  # class-level annotation required by strict mode
+    _state: dict[str, bool]
+    _initial: dict[str, bool]
+
+    def __init__(
+        self,
+        *,
+        connections: ConnectionsRepo,
+        settings: ServerSettingsRepo,
+        mode_repo: AppModeRepo,
+    ) -> None:
+        """Store the repositories used to list connections and persist flag changes."""
+        super().__init__()
+        self._connections = connections
+        self._settings = settings
+        self._mode_repo = mode_repo
+        self._state = {}
+        self._initial = {}
+
+    @override
+    def compose(self) -> ComposeResult:
+        """Show the title, the current global mode, the hint line, and the list."""
+        try:
+            current = self._mode_repo.get().mode
+        except AppModeNotSetError:
+            # Safe-by-default: an unset mode behaves as PROPOSE everywhere else.
+            current = Mode.PROPOSE
+        with Vertical(id="settings-dialog"):
+            yield Static("[bold]Auto-approve per server[/bold]")
+            yield Static(f"Global mode: {mode_markup(current)}")
+            yield Static("[dim]Space = toggle — Enter = save — Esc = cancel[/dim]")
+            yield ListView(id="settings-list")
+            yield Static("", id="settings-error")
+
+    def on_mount(self) -> None:
+        """Populate the list with every connection and its effective flag."""
+        list_view = self.query_one("#settings-list", ListView)
+        try:
+            connections = self._connections.list_all()
+            for connection in connections:
+                allowed = self._settings.get_or_default(connection.alias).auto_allowed
+                self._state[connection.alias] = allowed
+                self._initial[connection.alias] = allowed
+                _ = list_view.append(ServerRow(connection, auto_allowed=allowed))
+        except sqlite3.Error as exc:
+            error = CGATE_THEME.error
+            _ = self.query_one("#settings-error", Static).update(
+                f"[{error}]Could not read the servers:[/{error}] {exc}"
+            )
+            return
+        if self._state:
+            list_view.index = 0
+        list_view.focus()
+
+    def action_toggle_row(self) -> None:
+        """Flip the highlighted row's in-memory flag (no writes until Enter)."""
+        list_view = self.query_one("#settings-list", ListView)
+        row = list_view.highlighted_child
+        if not isinstance(row, ServerRow):
+            return
+        new_value = not self._state[row.alias]
+        self._state[row.alias] = new_value
+        row.set_auto_allowed(auto_allowed=new_value)
+
+    def action_commit(self) -> None:
+        """Persist every alias whose flag changed since the modal opened."""
+        try:
+            for alias, allowed in self._state.items():
+                if allowed != self._initial[alias]:
+                    _ = self._settings.set(
+                        alias=alias,
+                        auto_allowed=allowed,
+                        updated_by=_updated_by(),
+                    )
+        except sqlite3.Error as exc:
+            error = CGATE_THEME.error
+            _ = self.query_one("#settings-error", Static).update(
+                f"[{error}]Could not save the changes:[/{error}] {exc}"
+            )
+            return
+        self.dismiss(True)  # noqa: FBT003 - ModalScreen[bool].dismiss takes the result positionally
+
+    def action_cancel(self) -> None:
+        """Dismiss without writing anything."""
+        self.dismiss(False)  # noqa: FBT003 - ModalScreen[bool].dismiss takes the result positionally
+
+
+__all__ = ["ServerSettingsModal"]

cgate/watch/session.py

@@ -0,0 +1,40 @@
+"""Entry point for `cgate watch`: always launches the live approval dashboard."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from cgate.connections.store import ConnectionsRepo
+from cgate.db.batches import BatchesRepo
+from cgate.db.commands import CommandsRepo
+from cgate.db.mode import AppModeRepo
+from cgate.db.server_settings import ServerSettingsRepo
+from cgate.watch.app import WatchApp
+from cgate.watch.queue import heal_queue
+
+if TYPE_CHECKING:
+    from cgate.db.connection import Database
+
+
+def run_watch_session(db: Database) -> None:
+    """Launch the live approval dashboard, starting idle if the queue is empty.
+
+    The dashboard never exits on its own: it polls the database for new
+    batches and idles when the queue is empty or drains, so it survives
+    proposals that arrive at any point while it's open, not only ones
+    already pending when it was launched.
+    """
+    batches = BatchesRepo(db)
+    commands = CommandsRepo(db)
+    connections = ConnectionsRepo(db)
+    mode = AppModeRepo(db)
+    server_settings = ServerSettingsRepo(db)
+    heal_queue(batches, commands)
+    WatchApp(
+        db=db,
+        batches=batches,
+        commands=commands,
+        connections=connections,
+        mode=mode,
+        server_settings=server_settings,
+    ).run()

cgate/watch/theme.py

@@ -0,0 +1,32 @@
+"""The `cgate watch` dashboard's Textual theme -- single source for its palette.
+
+Lives in its own module (rather than `watch/app.py`, where it's activated)
+so `watch/render.py`'s pure markup helpers can pull the same hex values for
+status glyphs and warnings, instead of Rich's generic named colors drifting
+out of sync with whatever the app's theme actually is.
+"""
+
+from __future__ import annotations
+
+from textual.theme import Theme
+
+# Deep, near-black surfaces with a teal primary give the dashboard its own
+# identity instead of Textual's generic default. warning/error/success map
+# directly onto the semantics already baked into render.py's status glyphs
+# (pending/running=warning, executed=success, rejected/failed/risky=error).
+CGATE_THEME: Theme = Theme(
+    name="cgate",
+    primary="#2DD4BF",
+    secondary="#60A5FA",
+    warning="#FBBF24",
+    error="#F87171",
+    success="#4ADE80",
+    accent="#FB923C",
+    foreground="#E5E7EB",
+    background="#0B0E14",
+    surface="#12151C",
+    panel="#1E2330",
+    dark=True,
+)
+
+__all__ = ["CGATE_THEME"]

cgate/watch/widgets.py

@@ -0,0 +1,35 @@
+"""Shared Textual widgets used by both the live dashboard and the history browser."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from textual.widgets import Static
+
+from cgate.watch.render import format_command_line
+
+if TYPE_CHECKING:
+    from cgate.db.types import Command, CommandId
+
+
+class CommandRow(Static):
+    """One command line, updatable in place.
+
+    Lives in its own module (rather than `watch/app.py`, where it used
+    to be defined) so `watch/history_modal.py` can reuse it without
+    creating an import cycle back into `app.py`.
+    """
+
+    command_id: CommandId
+
+    def __init__(self, command: Command) -> None:
+        """Render the initial line for this command and remember its id."""
+        super().__init__(format_command_line(command), markup=True)
+        self.command_id = command.id
+
+    def update_command(self, command: Command) -> None:
+        """Refresh this row's text for the command's current state."""
+        _ = self.update(format_command_line(command))
+
+
+__all__ = ["CommandRow"]