command-gate 0.2.4__py3-none-any.whl

cgate/watch/approval.py

@@ -0,0 +1,237 @@
+"""Decision handlers for approving, executing, and rejecting commands."""
+
+from __future__ import annotations
+
+import getpass
+from typing import TYPE_CHECKING
+
+from cgate.db.types import CommandStatus
+from cgate.executor.selector import execute_command
+from cgate.watch.queue import is_batch_resolved
+
+if TYPE_CHECKING:
+    from cgate.connections.store import ConnectionsRepo
+    from cgate.db.batches import BatchesRepo
+    from cgate.db.commands import CommandsRepo
+    from cgate.db.connection import Database
+    from cgate.db.types import BatchId, Command, CommandId
+    from cgate.executor.base import ExecutionResult
+
+
+class ConnectionNotFoundError(LookupError):
+    """A command references a connection alias absent from local storage."""
+
+    alias: str
+
+    def __init__(self, alias: str) -> None:
+        """Store the missing alias for a useful boundary error."""
+        self.alias = alias
+        message = f"connection '{alias}' not found"
+        super().__init__(message)
+
+
+class CommandDisappearedError(RuntimeError):
+    """A command could not be fetched immediately after a status update."""
+
+    command_id: CommandId
+
+    def __init__(self, command_id: CommandId) -> None:
+        """Store the missing command ID for a useful boundary error."""
+        self.command_id = command_id
+        message = f"command {command_id} disappeared after status update"
+        super().__init__(message)
+
+
+def _approve_by() -> str:
+    """Return the OS username for the audit column."""
+    try:
+        return getpass.getuser()
+    except (KeyError, OSError):
+        return "unknown"
+
+
+def mark_approved(
+    *,
+    commands: CommandsRepo,
+    connections: ConnectionsRepo,
+    command_id: CommandId,
+) -> Command | None:
+    """Transition one pending command to APPROVED, without executing it.
+
+    The fast half of `approve_one`'s two-step split (paired with
+    `execute_and_finalize`): a plain DB write, done in milliseconds. The
+    watch TUI calls this first and refreshes before the slow half, so a
+    human sees the "approved, running" state (status glyph ◐) instead of
+    the queue looking frozen while the executor's timeout runs (up to a
+    minute by default).
+
+    Returns the command as-is (still PENDING) if `expected_status` loses
+    a race with another decision on it, or if it's already past PENDING
+    for any other reason -- mirroring `approve_one`'s prior behavior.
+    """
+    command = commands.get(command_id)
+    if command is None or command.status is not CommandStatus.PENDING:
+        return command
+    connection = connections.get(command.server_alias)
+    if connection is None:
+        raise ConnectionNotFoundError(command.server_alias)
+    approved = commands.update_status(
+        command_id,
+        status=CommandStatus.APPROVED,
+        approved_by=_approve_by(),
+        expected_status=CommandStatus.PENDING,
+    )
+    return commands.get(command_id) if approved else command
+
+
+def execute_and_finalize(  # noqa: PLR0913 - signature follows the required repository DI boundary
+    *,
+    db: Database,
+    commands: CommandsRepo,
+    connections: ConnectionsRepo,
+    batches: BatchesRepo,
+    command_id: CommandId,
+    timeout: float = 60.0,
+) -> tuple[Command | None, ExecutionResult | None]:
+    """Execute an already-APPROVED command and stamp EXECUTED/FAILED.
+
+    The slow half of `approve_one`'s two-step split: the network call
+    that can take up to `timeout`. No-ops (returns the command as-is, no
+    ExecutionResult) if it isn't APPROVED -- `mark_approved` lost a race,
+    or a human rejected it in the gap between the two calls.
+    """
+    del db
+    command = commands.get(command_id)
+    if command is None or command.status is not CommandStatus.APPROVED:
+        return command, None
+    connection = connections.get(command.server_alias)
+    if connection is None:
+        raise ConnectionNotFoundError(command.server_alias)
+    approver = command.approved_by or _approve_by()
+    result = execute_command(connection, command.command, timeout=timeout)
+    status = CommandStatus.EXECUTED if result.ok else CommandStatus.FAILED
+    output = result.stdout
+    if result.stderr:
+        separator = "\n" if output else ""
+        output = f"{output}{separator}--- stderr ---\n{result.stderr}"
+    _ = commands.update_status(
+        command_id,
+        status=status,
+        approved_by=approver,
+        result=output,
+    )
+    updated = commands.get(command_id)
+    if updated is None:
+        raise CommandDisappearedError(command_id)
+    _maybe_resolve_batch(batches, commands, updated.batch_id)
+    return updated, result
+
+
+def approve_one(  # noqa: PLR0913 - signature follows the required repository DI boundary
+    *,
+    db: Database,
+    commands: CommandsRepo,
+    connections: ConnectionsRepo,
+    batches: BatchesRepo,
+    command_id: CommandId,
+    timeout: float = 60.0,
+) -> tuple[Command | None, ExecutionResult | None]:
+    """Approve and synchronously execute one pending command.
+
+    Composes `mark_approved` + `execute_and_finalize` in one call, for
+    callers that don't need the mid-flight refresh those two are split
+    for: `approve_remaining` and the MCP AUTO-mode auto-execution path.
+    """
+    _ = mark_approved(commands=commands, connections=connections, command_id=command_id)
+    return execute_and_finalize(
+        db=db,
+        commands=commands,
+        connections=connections,
+        batches=batches,
+        command_id=command_id,
+        timeout=timeout,
+    )
+
+
+def reject_one(
+    *,
+    commands: CommandsRepo,
+    batches: BatchesRepo,
+    command_id: CommandId,
+) -> Command:
+    """Reject one command and resolve its batch when it becomes terminal."""
+    _ = commands.update_status(
+        command_id,
+        status=CommandStatus.REJECTED,
+        approved_by=_approve_by(),
+        expected_status=CommandStatus.PENDING,
+    )
+    updated = commands.get(command_id)
+    if updated is None:
+        raise CommandDisappearedError(command_id)
+    _maybe_resolve_batch(batches, commands, updated.batch_id)
+    return updated
+
+
+def approve_remaining(  # noqa: PLR0913 - signature follows the required repository DI boundary
+    *,
+    db: Database,
+    commands: CommandsRepo,
+    connections: ConnectionsRepo,
+    batches: BatchesRepo,
+    remaining: list[Command],
+    timeout: float = 60.0,
+) -> list[tuple[Command, ExecutionResult | None]]:
+    """Approve and execute pending commands in their natural order."""
+    results: list[tuple[Command, ExecutionResult | None]] = []
+    for command in remaining:
+        if command.status is not CommandStatus.PENDING:
+            continue
+        try:
+            updated, result = approve_one(
+                db=db,
+                commands=commands,
+                connections=connections,
+                batches=batches,
+                command_id=command.id,
+                timeout=timeout,
+            )
+        except Exception as exc:
+            _ = commands.update_status(
+                command.id,
+                status=CommandStatus.FAILED,
+                approved_by=_approve_by(),
+                result=f"approval/connect failed: {exc}",
+            )
+            updated = commands.get(command.id)
+            result = None
+            if updated is None:
+                raise CommandDisappearedError(command.id) from exc
+            _maybe_resolve_batch(batches, commands, updated.batch_id)
+        if updated is not None:
+            results.append((updated, result))
+    return results
+
+
+def reject_remaining(
+    *,
+    commands: CommandsRepo,
+    batches: BatchesRepo,
+    remaining: list[Command],
+) -> list[Command]:
+    """Reject each pending command in its natural order."""
+    return [
+        reject_one(commands=commands, batches=batches, command_id=command.id)
+        for command in remaining
+        if command.status is CommandStatus.PENDING
+    ]
+
+
+def _maybe_resolve_batch(
+    batches: BatchesRepo,
+    commands: CommandsRepo,
+    batch_id: BatchId,
+) -> None:
+    """Stamp a batch when every command has reached a terminal status."""
+    if is_batch_resolved(commands.list_for_batch(batch_id)):
+        batches.mark_resolved(batch_id)

cgate/watch/command_detail_modal.py

@@ -0,0 +1,68 @@
+"""Read-only detail view for one command: full result, reason, audit fields."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, ClassVar
+
+from textual.binding import Binding
+from textual.containers import Vertical, VerticalScroll
+from textual.screen import ModalScreen
+from textual.widgets import Static
+from typing_extensions import override
+
+from cgate.watch.render import format_command_detail
+
+if TYPE_CHECKING:
+    from textual.app import ComposeResult
+    from textual.binding import BindingType
+
+    from cgate.db.types import Command
+
+
+class CommandDetailModal(ModalScreen[None]):
+    """Full detail for one command: untruncated result, reason, and approver.
+
+    Unlike the queue rows -- capped at `render._RESULT_SNIPPET_MAX_CHARS`
+    and one line -- this shows the command's full result. Read-only:
+    makes no writes, dismisses on Escape or Enter.
+    """
+
+    CSS: ClassVar[str] = """
+    CommandDetailModal { align: center middle; }
+    #detail-dialog {
+        width: 90%;
+        height: 80%;
+        border: round $primary;
+        background: $surface;
+        padding: 1 2;
+    }
+    #detail-body { height: 1fr; margin-top: 1; }
+    """
+
+    BINDINGS: ClassVar[list[BindingType]] = [
+        Binding("escape", "close", "Close", show=False, priority=True),
+        Binding("enter", "close", "Close", show=False, priority=True),
+    ]
+
+    _command: Command
+
+    def __init__(self, command: Command) -> None:
+        """Remember the command whose detail this modal shows."""
+        super().__init__()
+        self._command = command
+
+    @override
+    def compose(self) -> ComposeResult:
+        """Show the title, the full command detail, and the close hint."""
+        with Vertical(id="detail-dialog"):
+            yield Static("[bold]Command detail[/bold]")
+            with VerticalScroll(id="detail-body"):
+                yield Static(format_command_detail(self._command), id="detail-text", markup=True)
+            yield Static("[dim]Esc / Enter = close[/dim]")
+
+    def action_close(self) -> None:
+        """Dismiss without writing anything -- this view is read-only."""
+        _ = self.dismiss(None)
+
+
+__all__ = ["CommandDetailModal"]

cgate/watch/history_modal.py

@@ -0,0 +1,242 @@
+"""Read-only browser for resolved batches (`h` key in `cgate watch`).
+
+The live queue drops a batch the instant it resolves -- `resolve_at IS
+NULL` is exactly what makes it disappear from `list_pending`. Without
+this, there was no way to look back at anything that already went
+through: not in the TUI, not from any CLI command.
+"""
+
+from __future__ import annotations
+
+import sqlite3
+from typing import TYPE_CHECKING, ClassVar
+
+from textual.binding import Binding
+from textual.containers import Horizontal, Vertical, VerticalScroll
+from textual.screen import ModalScreen
+from textual.widgets import Input, ListItem, ListView, Static
+from typing_extensions import override
+
+from cgate.watch.command_detail_modal import CommandDetailModal
+from cgate.watch.render import format_batch_header
+from cgate.watch.theme import CGATE_THEME
+from cgate.watch.widgets import CommandRow
+
+if TYPE_CHECKING:
+    from textual.app import ComposeResult
+    from textual.binding import BindingType
+
+    from cgate.db.batches import BatchesRepo
+    from cgate.db.commands import CommandsRepo
+    from cgate.db.types import Batch, BatchId
+
+_HISTORY_LIMIT = 50
+
+
+class BatchHistoryRow(ListItem):
+    """One resolved batch in the history list, carrying its id for lookups."""
+
+    batch_id: BatchId
+
+    def __init__(self, batch: Batch) -> None:
+        """Render the resolved timestamp and title, and remember the batch id."""
+        resolved = batch.resolved_at.strftime("%Y-%m-%d %H:%M") if batch.resolved_at else "?"
+        super().__init__(Static(f"[dim]{resolved}[/dim]  {batch.title}", markup=True))
+        self.batch_id = batch.id
+
+
+class HistoryModal(ModalScreen[None]):
+    """Browse resolved batches: title/timestamp list on the left, commands on the right.
+
+    Press `/` to filter (fzf/vim-style): the list narrows live against
+    every batch's title, description, and its commands' text/server alias.
+    Escape exits filter mode first, then closes the modal on a second press.
+    """
+
+    CSS: ClassVar[str] = """
+    HistoryModal { align: center middle; }
+    #history-dialog {
+        width: 96%;
+        height: 90%;
+        border: round $primary;
+        background: $surface;
+    }
+    #history-title { padding: 1 2 0 2; }
+    #history-hint { padding: 0 2 1 2; }
+    #history-body { height: 1fr; }
+    #history-list-pane { width: 40; border-right: solid $panel; padding: 1; }
+    #history-filter { margin-bottom: 1; }
+    #history-detail-pane { padding: 1 2; }
+    """
+
+    BINDINGS: ClassVar[list[BindingType]] = [
+        Binding("escape", "close", "Close", priority=True),
+        # Not priority: a focused #history-filter Input must still receive a
+        # literal "q" character while the human is typing a query.
+        Binding("q", "close", "Close", show=False),
+        Binding("slash", "search", "Filter", priority=True),
+    ]
+
+    _batches: BatchesRepo
+    _commands: CommandsRepo
+    _resolved: list[Batch]
+    _visible: list[Batch]
+    _search_text: dict[BatchId, str]
+
+    def __init__(self, *, batches: BatchesRepo, commands: CommandsRepo) -> None:
+        """Store the repositories used to list resolved batches and their commands."""
+        super().__init__()
+        self._batches = batches
+        self._commands = commands
+        self._resolved = []
+        self._visible = []
+        self._search_text = {}
+
+    @override
+    def compose(self) -> ComposeResult:
+        """Lay out the title, the filter input, the resolved-batch list, and the detail pane."""
+        with Vertical(id="history-dialog"):
+            yield Static("[bold]History[/bold] [dim](most recently resolved first)[/dim]",
+                          id="history-title")
+            with Horizontal(id="history-body"):
+                with Vertical(id="history-list-pane"):
+                    yield Input(placeholder="/ to filter…", id="history-filter")
+                    yield ListView(id="history-list")
+                with VerticalScroll(id="history-detail-pane"):
+                    yield Static(id="history-detail-header")
+                    yield ListView(id="history-rows")
+            yield Static(
+                (
+                    "[dim]↑/↓ = browse batches — Enter on a command = view full result "
+                    "— / = filter — Esc = close[/dim]"
+                ),
+                id="history-hint",
+            )
+
+    def on_mount(self) -> None:
+        """Load the resolved batches, index them for filtering, and show the newest."""
+        try:
+            self._resolved = self._batches.list_resolved(limit=_HISTORY_LIMIT)
+        except sqlite3.Error as exc:
+            error = CGATE_THEME.error
+            self.query_one("#history-detail-header", Static).update(
+                f"[{error}]Could not read history:[/{error}] {exc}"
+            )
+            return
+        self._search_text = {batch.id: self._index_batch(batch) for batch in self._resolved}
+        self._visible = self._resolved
+        self._rebuild_list()
+        _ = self.query_one("#history-list", ListView).focus()
+
+    def _index_batch(self, batch: Batch) -> str:
+        """Build the lowercased blob `_apply_filter` matches a query against.
+
+        Best-effort: a DB hiccup while indexing one batch's commands just
+        means that batch won't match on its command/server text -- title
+        and description still will -- rather than breaking the whole list.
+        """
+        parts = [batch.title, batch.description or ""]
+        try:
+            for command in self._commands.list_for_batch(batch.id):
+                parts.append(command.command)
+                parts.append(command.server_alias)
+        except sqlite3.Error:
+            pass
+        return " ".join(parts).lower()
+
+    def action_search(self) -> None:
+        """Focus the filter input (`/`), fzf/vim-style."""
+        _ = self.query_one("#history-filter", Input).focus()
+
+    def on_input_changed(self, event: Input.Changed) -> None:
+        """Re-filter the batch list live as the query changes."""
+        if event.input.id != "history-filter":
+            return
+        self._apply_filter(event.value)
+
+    def on_input_submitted(self, event: Input.Submitted) -> None:
+        """Enter in the filter jumps focus to the (now-narrowed) results list."""
+        if event.input.id != "history-filter":
+            return
+        _ = self.query_one("#history-list", ListView).focus()
+
+    def _apply_filter(self, query: str) -> None:
+        """Narrow `_visible` to batches whose index contains `query`, then re-render."""
+        normalized = query.strip().lower()
+        self._visible = (
+            self._resolved
+            if not normalized
+            else [b for b in self._resolved if normalized in self._search_text.get(b.id, "")]
+        )
+        self._rebuild_list()
+
+    def _rebuild_list(self) -> None:
+        """Redraw #history-list from `_visible` and show the first match's detail."""
+        list_view = self.query_one("#history-list", ListView)
+        _ = list_view.clear()
+        for batch in self._visible:
+            _ = list_view.append(BatchHistoryRow(batch))
+        if self._visible:
+            list_view.index = 0
+            self._show_batch(self._visible[0])
+            return
+        message = "No resolved batches yet." if not self._resolved else "No matches."
+        self.query_one("#history-detail-header", Static).update(f"[dim]{message}[/dim]")
+        _ = self.query_one("#history-rows", ListView).clear()
+
+    def on_list_view_highlighted(self, event: ListView.Highlighted) -> None:
+        """Show the highlighted batch's commands as the sidebar cursor moves."""
+        if event.list_view.id != "history-list" or event.item is None:
+            return
+        if isinstance(event.item, BatchHistoryRow):
+            batch = next(
+                (b for b in self._resolved if b.id == event.item.batch_id), None
+            )
+            if batch is not None:
+                self._show_batch(batch)
+
+    def on_list_view_selected(self, event: ListView.Selected) -> None:
+        """Open the full-detail modal for the command highlighted in the detail pane."""
+        if event.list_view.id != "history-rows":
+            return
+        row = event.item.query_one(CommandRow)
+        try:
+            command = self._commands.get(row.command_id)
+        except sqlite3.Error as exc:
+            error = CGATE_THEME.error
+            self.query_one("#history-detail-header", Static).update(
+                f"[{error}]Could not read this command:[/{error}] {exc}"
+            )
+            return
+        if command is not None:
+            _ = self.app.push_screen(CommandDetailModal(command))  # pyright: ignore[reportUnknownMemberType]
+
+    def _show_batch(self, batch: Batch) -> None:
+        """Render one resolved batch's header and its commands in the detail pane."""
+        self.query_one("#history-detail-header", Static).update(format_batch_header(batch))
+        rows = self.query_one("#history-rows", ListView)
+        _ = rows.clear()
+        try:
+            commands_in_batch = self._commands.list_for_batch(batch.id)
+        except sqlite3.Error as exc:
+            error = CGATE_THEME.error
+            self.query_one("#history-detail-header", Static).update(
+                f"[{error}]Could not read this batch's commands:[/{error}] {exc}"
+            )
+            return
+        for command in commands_in_batch:
+            _ = rows.append(ListItem(CommandRow(command)))
+        if commands_in_batch:
+            rows.index = 0
+
+    def action_close(self) -> None:
+        """Exit filter mode first if it's active; otherwise dismiss (read-only view)."""
+        filter_input = self.query_one("#history-filter", Input)
+        if self.focused is filter_input or filter_input.value:
+            filter_input.value = ""
+            _ = self.query_one("#history-list", ListView).focus()
+            return
+        _ = self.dismiss(None)
+
+
+__all__ = ["HistoryModal"]

cgate/watch/mode_modal.py

@@ -0,0 +1,110 @@
+"""Confirmation modal for toggling the global behavior mode (PROPOSE <-> AUTO)."""
+
+from __future__ import annotations
+
+import getpass
+import sqlite3
+from typing import TYPE_CHECKING, ClassVar
+
+from textual.containers import Vertical
+from textual.screen import ModalScreen
+from textual.widgets import Static
+from typing_extensions import override
+
+from cgate.db.mode import AppModeNotSetError, Mode
+from cgate.watch.theme import CGATE_THEME
+
+if TYPE_CHECKING:
+    from textual.app import ComposeResult
+    from textual.events import Key
+
+    from cgate.db.mode import AppModeRepo
+
+
+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 mode_markup(mode: Mode) -> str:
+    """Render a mode label: warning-colored for PROPOSE (safe), error for AUTO (live fire)."""
+    match mode:
+        case Mode.PROPOSE:
+            warning = CGATE_THEME.warning
+            return f"[{warning}]PROPOSE[/{warning}]"
+        case Mode.AUTO:
+            error = CGATE_THEME.error
+            return f"[{error}]AUTO ⚡[/{error}]"
+
+
+class ModeModal(ModalScreen[bool]):
+    """Ask the user to confirm switching the global mode to the OTHER mode.
+
+    Dismisses with ``True`` when the user pressed ``y`` and the new mode was
+    persisted; dismisses with ``False`` on any other key, with no writes.
+    """
+
+    CSS: ClassVar[str] = """
+    ModeModal { align: center middle; }
+    #mode-dialog {
+        width: 64;
+        height: auto;
+        border: round $primary;
+        background: $surface;
+        padding: 1 2;
+    }
+    #mode-error { color: $error; }
+    """
+
+    _mode_repo: AppModeRepo  # class-level annotation required by strict mode
+    _target: Mode  # class-level annotation required by strict mode
+
+    def __init__(self, *, mode_repo: AppModeRepo) -> None:
+        """Store the repository used to read the current mode and persist the new one."""
+        super().__init__()
+        self._mode_repo = mode_repo
+        self._target = Mode.PROPOSE
+
+    @override
+    def compose(self) -> ComposeResult:
+        """Show the current mode, the target mode, and the confirm/cancel hint."""
+        try:
+            current = self._mode_repo.get().mode
+        except AppModeNotSetError:
+            # Safe-by-default: an unset mode behaves as PROPOSE everywhere else.
+            current = Mode.PROPOSE
+        self._target = Mode.AUTO if current is Mode.PROPOSE else Mode.PROPOSE
+        with Vertical(id="mode-dialog"):
+            yield Static("[bold]Switch global mode[/bold]")
+            yield Static(f"Current mode: {mode_markup(current)}")
+            yield Static(f"Switch to:    {mode_markup(self._target)}")
+            if self._target is Mode.AUTO:
+                error = CGATE_THEME.error
+                warning_text = (
+                    f"[{error}]In AUTO mode, commands for servers with auto-approve "
+                    f"run without manual approval.[/{error}]"
+                )
+                yield Static(warning_text)
+            yield Static("[dim]y = confirm — any other key cancels[/dim]")
+            yield Static("", id="mode-error")
+
+    def on_key(self, event: Key) -> None:
+        """Confirm on ``y``; cancel on any other key, writing nothing."""
+        if event.key != "y":
+            self.dismiss(False)  # noqa: FBT003 - ModalScreen[bool].dismiss takes the result positionally
+            return
+        try:
+            _ = self._mode_repo.set(mode=self._target, updated_by=_updated_by())
+        except sqlite3.Error as exc:
+            error = CGATE_THEME.error
+            _ = self.query_one("#mode-error", Static).update(
+                f"[{error}]Could not save the mode:[/{error}] {exc}"
+            )
+            return
+        self.dismiss(True)  # noqa: FBT003 - ModalScreen[bool].dismiss takes the result positionally
+
+
+__all__ = ["ModeModal"]