gitpane 1.0.0__py3-none-any.whl

gitpane/ui/transport/push_dialog.py

@@ -0,0 +1,580 @@
+"""Collect explicit push destinations without performing repository operations."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, NamedTuple
+
+from PySide6.QtCore import Qt, Signal
+from PySide6.QtWidgets import QCheckBox, QDialog, QFileDialog, QGridLayout, QGroupBox, QHBoxLayout, QLayout, QLineEdit, QPushButton, QRadioButton, QScrollArea, QTabWidget, QVBoxLayout, QWidget
+from shiboken6 import isValid
+
+from gitpane.config import LOCAL_PREFIX, REMOTE_PREFIX, TAG_PREFIX
+from gitpane.operation.diagnostic import SensitiveTextFilter
+from gitpane.operation.operation_status import OperationStatus
+from gitpane.operation.repository_operation import OWNED_REPOSITORY_TEXT
+from gitpane.text.typed_path import session_typed_path, typed_path_value, typed_start_dir
+from gitpane.text.typed_text import typed_value
+from gitpane.transport.refusal_notice import failure_headline, failure_summary, headline_first, is_no_account_refusal, server_refusal_headline
+from gitpane.transport.remote_config import default_push_destination_name, fetch_remote_name
+from gitpane.ui.look.action_icon import action_icon
+from gitpane.ui.transport.push_rejection_prompt import FORCE_WITH_LEASE_LABEL
+from gitpane.ui.widget.content_growth import ContentGrowthMixin, OpeningFit
+from gitpane.ui.widget.content_measure import ScrolledContentMeasure
+from gitpane.ui.widget.dialog_layout import fit_form
+from gitpane.ui.widget.long_text import WrappingLabel
+from gitpane.ui.widget.result_label import ResultLabel
+from gitpane.ui.widget.wheel_safe_drop_down import UrlSelector
+
+if TYPE_CHECKING:
+    from collections.abc import Callable
+
+    from PySide6.QtCore import QRect
+    from PySide6.QtGui import QShowEvent
+
+    from gitpane.commit.commit_push import CommitPushIntent
+    from gitpane.transport.branch_exchange import PushTarget, TransportOutcome
+    from gitpane.transport.refusal_notice import TransferAccount
+    from gitpane.transport.remote_config import RemoteSnapshot
+
+    # The draft a Push window sends: its capture, remote name, endpoint, source ref, destination ref, force, push target
+    # and the tag refs with their objects. Only type checkers read it, so the names above need no import at run time.
+    PushWindowRequest = tuple[RemoteSnapshot, str, str, str, str, bool, PushTarget | None, tuple[tuple[str, str], ...]]
+
+PUSH_DIALOG_WIDTH = 800
+PUSH_DIALOG_HEIGHT = 480
+BRANCH_TAB_INDEX = 0
+TAG_TAB_INDEX = 1
+TAG_SELECTION_ROLE = Qt.ItemDataRole.UserRole + 1
+ALL_TAG_SELECTION = ""
+
+
+class PinnedTag(NamedTuple):
+    """The one tag object a creation follow-up may push, and the remote the tag creation proposed for it.
+
+    An empty remote name leaves the remote choice to Push.
+    """
+
+    full_ref: str
+    object_oid: str
+    remote_name: str = ""
+
+    def selection(self) -> tuple[tuple[str, str], ...]:
+        """Answer the tag list entry that stands for exactly this tag object, in the form the tag selector stores."""
+        return ((self.full_ref, self.object_oid),)
+
+
+class PushDialog(ContentGrowthMixin, QDialog):
+    """Retain one repository's source and destination draft until an explicit Push."""
+
+    push_requested = Signal(object)
+    remote_requested = Signal()
+    reread_requested = Signal()
+    destination_changed = Signal()
+
+    def __init__(self, repository_dir: str, parent: QWidget | None = None, *, is_available: Callable[[], bool] | None = None,
+                 typed_path: Callable[[str], str] = session_typed_path) -> None:
+        """Place scrolling fields above permanent actions and preserve native keyboard behavior.
+
+        ``typed_path`` reads ``~`` in the Url field where that is the usage; the tests hand their own system and home
+        folder.
+        """
+        super().__init__(parent)
+        self.typed_path = typed_path
+        self.snapshot: RemoteSnapshot | None = None
+        self.commit_push_intent: CommitPushIntent | None = None
+        self.commit_push_message = ""
+        self.created_tag: PinnedTag | None = None
+        self.closed = False
+        self.busy = False
+        self.loading = True
+        self.request: PushWindowRequest | None = None
+        self.operation_id = ""
+        self.push_target: PushTarget | None = None
+        self.target_error = ""
+        self.needs_reread = False
+        self.is_available = is_available or (lambda: True)
+        self.available = self.is_available()
+        self.return_focus = parent.focusWidget() if parent else None
+        self.text_filter = SensitiveTextFilter()
+        self.setWindowTitle("Push (" + repository_dir + ")")
+        layout = QVBoxLayout(self)
+        layout.setSizeConstraint(QLayout.SizeConstraint.SetNoConstraint)
+        self.scroll_area = QScrollArea()
+        self.scroll_area.setWidgetResizable(True)
+        self.content = QWidget()
+        body = QVBoxLayout(self.content)
+        self.commit_result_label = ResultLabel()
+        self.commit_result_label.hide()
+        body.addWidget(self.commit_result_label)
+        destination_group = QGroupBox("Push to")
+        destination = QGridLayout(destination_group)
+        self.remote_radio = QRadioButton("Remote")
+        self.remote_radio.setChecked(True)
+        self.url_radio = QRadioButton("Url")
+        self.remote_selector = UrlSelector()
+        self.remote_selector.setAccessibleName("Push remote")
+        self.manage_button = QPushButton("Manage remotes")
+        self.url_edit = QLineEdit()
+        self.url_edit.setAccessibleName("Push Url")
+        self.browse_button = QPushButton("Browse…")
+        self.browse_button.setAccessibleName("Browse Push repository")
+        destination.addWidget(self.remote_radio, 0, 0)
+        destination.addWidget(self.remote_selector, 0, 1)
+        destination.addWidget(self.manage_button, 0, 2)
+        destination.addWidget(self.url_radio, 1, 0)
+        destination.addWidget(self.url_edit, 1, 1)
+        destination.addWidget(self.browse_button, 1, 2)
+        self.endpoint_selector = UrlSelector()
+        self.endpoint_selector.setAccessibleName("Push endpoint")
+        endpoint_label = WrappingLabel("Push endpoint")
+        endpoint_label.setBuddy(self.endpoint_selector)
+        destination.addWidget(endpoint_label, 2, 0)
+        destination.addWidget(self.endpoint_selector, 2, 1, 1, 2)
+        body.addWidget(destination_group)
+        self.tabs = QTabWidget()
+        branch_page = QWidget()
+        branch = QGridLayout(branch_page)
+        branch.setColumnStretch(1, 1)
+        branch.setColumnStretch(3, 1)
+        self.local_label = WrappingLabel("Local branch")
+        self.destination_label = WrappingLabel("Remote branch")
+        self.source_selector = UrlSelector()
+        self.source_selector.setAccessibleName("Local branch to push")
+        self.destination_selector = UrlSelector()
+        self.destination_selector.setEditable(True)
+        self.destination_selector.setAccessibleName("Remote branch destination")
+        self.destination_selector.lineEdit().setPlaceholderText("Existing or new branch name")
+        self.local_label.setBuddy(self.source_selector)
+        self.destination_label.setBuddy(self.destination_selector)
+        branch.addWidget(self.local_label, 0, 1)
+        branch.addWidget(self.destination_label, 0, 3)
+        branch.addWidget(WrappingLabel("Branch to push"), 1, 0)
+        branch.addWidget(self.source_selector, 1, 1)
+        branch.addWidget(WrappingLabel("to"), 1, 2)
+        branch.addWidget(self.destination_selector, 1, 3)
+        self.options_check = QCheckBox("Show options")
+        self.force_check = QCheckBox(FORCE_WITH_LEASE_LABEL)
+        self.force_check.hide()
+        self.options_check.toggled.connect(lambda checked: self.force_check.setVisible(checked or self.force_check.isChecked()))
+        self.force_check.toggled.connect(lambda checked: self.options_check.setChecked(True) if checked else None)
+        branch.addWidget(self.options_check, 2, 1)
+        branch.addWidget(self.force_check, 3, 1)
+        branch.setRowStretch(4, 1)
+        self.tabs.addTab(branch_page, "Push branches")
+        tag_page = QWidget()
+        tag_layout = QGridLayout(tag_page)
+        tag_label = WrappingLabel("Tag to push")
+        self.tag_selector = UrlSelector()
+        self.tag_selector.setAccessibleName("Tag to push")
+        tag_label.setBuddy(self.tag_selector)
+        tag_label_row, tag_force_row, tag_spacer_row = 0, 1, 2
+        tag_label_column, tag_selector_column = 0, 1
+        tag_layout.addWidget(tag_label, tag_label_row, tag_label_column)
+        tag_layout.addWidget(self.tag_selector, tag_label_row, tag_selector_column)
+        self.tag_force_check = QCheckBox(FORCE_WITH_LEASE_LABEL)
+        tag_layout.addWidget(self.tag_force_check, tag_force_row, tag_selector_column)
+        tag_layout.setColumnStretch(tag_selector_column, 1)
+        tag_layout.setRowStretch(tag_spacer_row, 1)
+        self.tabs.addTab(tag_page, "Push tags")
+        body.addWidget(self.tabs, 1)
+        self.status_label = ResultLabel("Reading source and destination…")
+        body.addWidget(self.status_label)
+        self.scroll_area.setWidget(self.content)
+        # The note of a refused Commit & push, a refusal in the status line and the reread that replaces it arrive after
+        # the window opened, and the window follows them both ways by the rule it shares with the other forms, within
+        # its screen, never below the height it opened at or the one the user set.
+        self.install_content_growth(ScrolledContentMeasure(self.scroll_area), OpeningFit.GROW_ONLY, PUSH_DIALOG_HEIGHT)
+        layout.addWidget(self.scroll_area, 1)
+        actions = QHBoxLayout()
+        self.reread_button = QPushButton("Reread destination")
+        self.close_button = QPushButton("Close")
+        self.push_button = QPushButton("Push")
+        self.push_button.setIcon(action_icon("push", self.devicePixelRatioF()))
+        actions.addWidget(self.reread_button)
+        actions.addStretch()
+        actions.addWidget(self.close_button)
+        actions.addWidget(self.push_button)
+        layout.addLayout(actions)
+        for button in (self.manage_button, self.browse_button, self.reread_button, self.close_button, self.push_button):
+            button.setAutoDefault(False)
+        self.push_button.clicked.connect(self.submit)
+        self.close_button.clicked.connect(self.reject)
+        self.manage_button.clicked.connect(self.remote_requested.emit)
+        self.reread_button.clicked.connect(self.reread_requested.emit)
+        self.browse_button.clicked.connect(self.browse)
+        self.remote_selector.currentIndexChanged.connect(self._remote_changed)
+        self.endpoint_selector.currentIndexChanged.connect(self._endpoint_changed)
+        self.source_selector.currentIndexChanged.connect(self._source_changed)
+        self.tag_selector.currentIndexChanged.connect(self.update_action)
+        self.tag_selector.currentIndexChanged.connect(self.reset_force)
+        self.source_selector.currentIndexChanged.connect(self.reset_force)
+        self.destination_selector.editTextChanged.connect(self.update_action)
+        self.destination_selector.editTextChanged.connect(self.reset_force)
+        self.destination_changed.connect(self.reset_force)
+        self.remote_radio.toggled.connect(self._mode_changed)
+        self.url_edit.textChanged.connect(lambda _text: self.destination_changed.emit() if not self.remote_radio.isChecked() else None)
+        self.url_edit.textChanged.connect(self.update_action)
+        self.tabs.currentChanged.connect(self.update_action)
+        self.tabs.currentChanged.connect(self.reset_force)
+        self.finished.connect(self._closed)
+        self.resize(PUSH_DIALOG_WIDTH, PUSH_DIALOG_HEIGHT)
+        self.refresh_metrics()
+        self.update_action()
+
+    def populate(self, snapshot: RemoteSnapshot, head_ref: str | None, tag_oid_by_ref: dict[str, str]) -> None:
+        """Display captured refs and retain a prior draft without selecting a vanished remote."""
+        self.reset_force()
+        previous = self.snapshot
+        previous_endpoint = getattr(self, "endpoint", "")
+        remote_name = self.remote_selector.currentData() if previous else fetch_remote_name(snapshot, head_ref)
+        # A remote proposed by a tag creation that pinned this window before its first read is chosen once the remote
+        # list arrives; a later read keeps whatever remote the user chose since.
+        if not previous and self.created_tag is not None and self.created_tag.remote_name in snapshot.entry_by_name:
+            remote_name = self.created_tag.remote_name
+        source_ref = self.source_selector.currentData() if previous else head_ref
+        destination = self.destination_selector.currentText() if previous else ""
+        tag_selection = self.tag_selector.currentData(TAG_SELECTION_ROLE) if previous else ALL_TAG_SELECTION
+        if self.created_tag is not None:
+            tag_selection = self.created_tag.full_ref
+        self.loading = True
+        self.snapshot = snapshot
+        self.needs_reread = False
+        self.remote_selector.clear()
+        for name in sorted(snapshot.entry_by_name):
+            entry = snapshot.entry_by_name[name]
+            self.remote_selector.addItem(name + (" (inactive)" if not entry.active else ""), name)
+        self.remote_selector.setCurrentIndex(self.remote_selector.findData(remote_name))
+        self.source_selector.clear()
+        for full_ref in sorted(snapshot.tracking_by_ref):
+            self.source_selector.addItem(full_ref.removeprefix(LOCAL_PREFIX), full_ref)
+        self.source_selector.setCurrentIndex(self.source_selector.findData(source_ref))
+        if self.commit_push_intent is not None:
+            self.pin_commit(self.commit_push_intent, self.commit_push_message)
+        self.tag_selector.clear()
+        if tag_oid_by_ref:
+            self.tag_selector.addItem("[ All ]", tuple(sorted(tag_oid_by_ref.items())))
+            self.tag_selector.setItemData(self.tag_selector.count() - 1, ALL_TAG_SELECTION, TAG_SELECTION_ROLE)
+        for full_ref in sorted(tag_oid_by_ref):
+            self.tag_selector.addItem(full_ref.removeprefix(TAG_PREFIX), ((full_ref, tag_oid_by_ref[full_ref]),))
+            self.tag_selector.setItemData(self.tag_selector.count() - 1, full_ref, TAG_SELECTION_ROLE)
+        self.tag_selector.setCurrentIndex(self.tag_selector.findData(tag_selection, TAG_SELECTION_ROLE))
+        if self.created_tag is not None:
+            self._lock_pinned_tag()
+        self.loading = False
+        self._remote_changed()
+        self._source_changed()
+        if previous:
+            self.destination_selector.setEditText(destination)
+            self.endpoint_selector.setCurrentIndex(self.endpoint_selector.findData(previous_endpoint))
+            self._endpoint_changed()
+        self.status_label.setText("Choose the source and destination, then Push.")
+        self.update_action()
+
+    def pin_tag(self, full_ref: str, object_oid: str, remote_name: str = "") -> bool:
+        """Restrict a creation follow-up to that exact tag object, never all tags, and choose the remote it proposed.
+
+        The remote is chosen only when the remote list already holds it; a list still being read gets it on arrival,
+        and a remote Push does not know is never added, so the choice stays Push's own.
+        """
+        if self.busy or self.commit_push_intent is not None:
+            return False
+        self.created_tag = PinnedTag(full_ref, object_oid, remote_name)
+        remote_index = self.remote_selector.findData(remote_name) if remote_name else -1
+        if remote_index >= 0:
+            self.remote_selector.setCurrentIndex(remote_index)
+        self._lock_pinned_tag()
+        self.reset_force()
+        self.update_action()
+        return True
+
+    def _lock_pinned_tag(self) -> None:
+        """Select the pinned tag object on the tag page and lock both the list and the branch page."""
+        index = self.tag_selector.findData(self.created_tag.full_ref, TAG_SELECTION_ROLE)
+        matches = index >= 0 and self.tag_selector.itemData(index) == self.created_tag.selection()
+        self.tag_selector.setCurrentIndex(index if matches else -1)
+        self.tag_selector.setEnabled(False)
+        self.tabs.setCurrentIndex(TAG_TAB_INDEX)
+        self.tabs.setTabEnabled(BRANCH_TAB_INDEX, False)
+
+    def pin_commit(self, intent: CommitPushIntent, message: str) -> None:
+        """Make a created commit the sole source while leaving its destination editable.
+
+        The note arrives once the window is already open, above the form; the window follows it by the shared content
+        rule, so the note and the whole form fit without scrolling, within its screen.
+        """
+        self.commit_push_intent = intent
+        self.commit_push_message = message
+        commit_text = self.text_filter.redact(message + "\nCommit: " + intent.created_oid)
+        reason_text = headline_first(intent.reason_headline, self.text_filter.redact(intent.reason) if intent.reason else "")
+        if reason_text:
+            commit_text += "\n" + reason_text
+        if intent.push_failed:
+            self.commit_result_label.show_failure(commit_text)
+        else:
+            self.commit_result_label.setText(commit_text)
+        self.commit_result_label.show()
+        self.source_selector.clear()
+        self.source_selector.addItem(intent.source_ref.removeprefix(LOCAL_PREFIX) + " — " + intent.created_oid, intent.source_ref or intent.created_oid)
+        self.source_selector.setEnabled(False)
+        self.tabs.setCurrentIndex(BRANCH_TAB_INDEX)
+        for index in range(self.tabs.count()):
+            self.tabs.setTabEnabled(index, index == BRANCH_TAB_INDEX)
+        self.reset_force()
+
+    def _remote_changed(self) -> None:
+        """Show the exact effective Push URL and require correction for an absent destination."""
+        if self.loading or self.snapshot is None:
+            return
+        entry = self.snapshot.entry_by_name.get(self.remote_selector.currentData())
+        self.endpoint_selector.clear()
+        for endpoint in entry.push_urls if entry is not None else ():
+            self.endpoint_selector.addItem(self.text_filter.redact(endpoint), endpoint)
+        self.endpoint_selector.setCurrentIndex(0 if entry is not None and len(entry.push_urls) == 1 else -1)
+        self._endpoint_changed()
+        destination = self.destination_selector.currentText()
+        self.destination_selector.clear()
+        remote_prefix = REMOTE_PREFIX + (self.remote_selector.currentData() or "") + "/"
+        for record in self.snapshot.references.splitlines():
+            full_ref, _separator, _rest = record.partition(b"\0")
+            name = full_ref.decode("utf-8", "surrogateescape")
+            if name.startswith(remote_prefix):
+                self.destination_selector.addItem(name.removeprefix(remote_prefix))
+        self.destination_selector.setEditText(destination)
+
+    def _endpoint_changed(self) -> None:
+        """Keep one full endpoint identity separate from its filtered display text."""
+        self.endpoint = self.endpoint_selector.currentData() or ""
+        if self.remote_radio.isChecked():
+            self.url_edit.setText(self.text_filter.redact(self.endpoint))
+        if not self.loading:
+            self.destination_changed.emit()
+        self.update_action()
+
+    def _source_changed(self) -> None:
+        """Suggest the local name for a branch without tracking, otherwise use its matching upstream."""
+        if self.loading or self.snapshot is None:
+            return
+        self.destination_selector.setEditText(default_push_destination_name(self.snapshot, self.source_selector.currentData(), self.remote_selector.currentData()))
+        self.update_action()
+
+    def _mode_changed(self) -> None:
+        """Switch the destination input without interpreting a displayed redacted URL as authority."""
+        remote_mode = self.remote_radio.isChecked()
+        self.remote_selector.setEnabled(remote_mode)
+        self.endpoint_selector.setEnabled(remote_mode)
+        self.url_edit.setEnabled(not remote_mode)
+        self.browse_button.setEnabled(not remote_mode)
+        if remote_mode:
+            self._remote_changed()
+        else:
+            self.url_edit.clear()
+        self.destination_changed.emit()
+        self.update_action()
+
+    def update_action(self, *_arguments: object) -> None:
+        """Disable incomplete, loading and unsupported submissions with a visible reason.
+
+        The reason is ordinary text, except GitPane's refusal to send without an account, shown in bold orange: nothing
+        is wrong with the draft, the user only has to choose an account in Settings.
+        """
+        if not hasattr(self, "push_button"):
+            return
+        reason = ""
+        if self.loading:
+            reason = "Reading source and destination…"
+        elif self.busy:
+            reason = "Push in progress…"
+        elif self.needs_reread:
+            reason = "Reread destination before another Push."
+        elif not self.available:
+            reason = OWNED_REPOSITORY_TEXT
+        elif self.created_tag is not None and self.tag_selector.currentData() != self.created_tag.selection():
+            reason = "The created tag changed or disappeared. Close Push and review the tag before sending."
+        elif self.tabs.currentIndex() != BRANCH_TAB_INDEX and not self.tag_selector.currentData():
+            reason = "Select a tag or explicitly choose [ All ] before pushing tags." if self.tag_selector.count() else "Create a tag from a commit before pushing tags."
+        elif self.tabs.currentIndex() == BRANCH_TAB_INDEX and not self.source_selector.currentData():
+            reason = "No local branch selected."
+        elif self.tabs.currentIndex() == BRANCH_TAB_INDEX and not self.typed_destination_branch():
+            reason = "Choose a remote branch destination."
+        elif not self.chosen_endpoint():
+            reason = "No remote configured. Use Manage remotes or Url to choose a destination."
+        elif self.target_error or self.push_target is None:
+            reason = self.target_error or "Choose a Push endpoint."
+        self.push_button.setEnabled(not reason and not self.closed)
+        if reason and is_no_account_refusal(reason):
+            self.status_label.show_warning(reason)
+        elif reason:
+            self.status_label.setText(reason)
+        else:
+            self.status_label.setText("Ready to push the selected branch." if self.tabs.currentIndex() == BRANCH_TAB_INDEX else "Ready to push the selected tags.")
+        self.url_edit.setEnabled(not self.remote_radio.isChecked())
+        self.browse_button.setEnabled(not self.remote_radio.isChecked())
+
+    def chosen_endpoint(self) -> str:
+        """Return where Push sends: the chosen remote's endpoint, or the typed Url without the blanks around it.
+
+        In the typed Url, ``~`` alone or ``~/…`` at the start stands for the home folder where that is the usage; only a
+        local folder address can change, since no HTTPS, SSH or ``file://`` address starts with ``~/``. The button
+        state, the account bound to the destination, the captured target and the request all read the address here, so
+        they always agree on the same address; the Url field keeps the text as typed.
+        """
+        if self.remote_radio.isChecked():
+            return getattr(self, "endpoint", "")
+        return typed_path_value(self.url_edit.text(), self.typed_path)
+
+    def typed_destination_branch(self) -> str:
+        """Return the remote branch typed or chosen, without the blanks around it; the field keeps the text as typed."""
+        return typed_value(self.destination_selector.currentText())
+
+    def submit(self) -> None:
+        """Emit the exact displayed draft once without executing Git from the widget."""
+        self.check_availability()
+        if not self.push_button.isEnabled() or self.snapshot is None:
+            return
+        endpoint = self.chosen_endpoint()
+        remote_name = self.remote_selector.currentData() if self.remote_radio.isChecked() else ""
+        branch_mode = self.tabs.currentIndex() == BRANCH_TAB_INDEX
+        tag_refs = () if branch_mode else tuple(self.tag_selector.currentData())
+        self.request = (self.snapshot, remote_name, endpoint, self.source_selector.currentData() if branch_mode else "",
+                        LOCAL_PREFIX + self.typed_destination_branch() if branch_mode else "",
+                        self.force_check.isChecked() if branch_mode else self.tag_force_check.isChecked(), self.push_target, tag_refs)
+        self.reset_force()
+        self.busy = True
+        self.content.setEnabled(False)
+        self.reread_button.setEnabled(False)
+        self.update_action()
+        self.push_requested.emit(self.request)
+
+    def cancel_send(self, force: bool) -> None:
+        """Give the draft back as it was before Push was clicked, when the user answers Cancel to a question asked before sending.
+
+        Nothing was sent and nothing went wrong, so no error is shown; Force comes back checked when it was, since
+        submit cleared it for the send that did not happen.
+        """
+        self.busy = False
+        self.request = None
+        self.content.setEnabled(True)
+        self.reread_button.setEnabled(True)
+        if self.tabs.currentIndex() == BRANCH_TAB_INDEX:
+            self.force_check.setChecked(force)
+        else:
+            self.tag_force_check.setChecked(force)
+        # check_availability ignores a busy window, so a repository taken by another owner meanwhile is only seen here.
+        self.available = self.is_available()
+        self.update_action()
+
+    def follow_operation(self, operation_id: str) -> None:
+        """Treat a push started for this draft from elsewhere (Force push with lease chosen after a refusal) as this window's own send."""
+        self.operation_id = operation_id
+        self.busy = True
+        self.content.setEnabled(False)
+        self.reread_button.setEnabled(False)
+        self.update_action()
+
+    def check_availability(self) -> None:
+        """Reflect another repository owner without replacing this operation's terminal details.
+
+        The transport controller connects it to each change of the repository operation register, so the window never polls.
+        """
+        if self.busy or self.closed:
+            return
+        available = self.is_available()
+        if available != self.available:
+            self.available = available
+            if not available:
+                self.reset_force()
+            self.update_action()
+
+    def reset_force(self, *_arguments: object) -> None:
+        """Require a fresh explicit choice for each target and each independent submission."""
+        self.force_check.setChecked(False)
+        self.tag_force_check.setChecked(False)
+
+    def show_error(self, message: str, headline: str = "") -> None:
+        """Keep failed drafts available and show only filtered plain-text diagnostics, in bold red.
+
+        GitPane's refusal to send without an account is shown in bold orange instead, as when Push opens: nothing was
+        sent and the user only has to choose an account in Settings.
+
+        A ``headline`` built by GitPane from an address and an account label comes first and is not filtered, so the
+        account it names stays readable. The window follows its status line both ways by the shared content rule: it
+        grows so the whole message and the form fit without scrolling, within its screen, and takes back its height
+        when the reread replaces the message.
+        """
+        self.reset_force()
+        self.busy = False
+        self.loading = False
+        self.content.setEnabled(True)
+        self.reread_button.setEnabled(True)
+        # check_availability ignores a busy window, so a repository released while this send was running is only seen here.
+        self.available = self.is_available()
+        self.update_action()
+        shown_text = headline_first(headline, self.text_filter.redact(message))
+        if is_no_account_refusal(shown_text):
+            self.status_label.show_warning(shown_text)
+        else:
+            self.status_label.show_failure(shown_text)
+
+    def show_outcome(self, outcome: TransportOutcome, account: TransferAccount | None = None) -> None:
+        """Close after a verified success, like Git Extensions; otherwise keep the draft and its details without any implicit second push.
+
+        A failure starts with the same sentence as the Push console: the branches the server itself refused (a hook,
+        for instance) with its message and reason, or else the address and the ``account`` used when the server refused
+        it. It ends with Git's own lines without debug traces or stack lines. The console keeps the full result and
+        follows its own Keep dialog open preference.
+        """
+        if outcome.status == OperationStatus.SUCCESS:
+            self.accept()
+            return
+        self.needs_reread = True
+        details = ["Push: " + outcome.status.value]
+        for result in outcome.remote_results:
+            details.append((result.remote_name or "Url") + " — " + result.endpoint + ": " + result.status.value + " (" + result.effect + ")")
+        for result in outcome.ref_results:
+            details.append(result.full_ref + ": " + result.status.value + " (" + result.effect + ")")
+        for step in outcome.steps:
+            details.append(step.operation + ": " + step.status.value)
+        if outcome.status == OperationStatus.UNKNOWN:
+            details.append("Outcome unknown. Review the same remote before another Push.")
+        elif outcome.status != OperationStatus.SUCCESS:
+            details.append("Push failed. Review the details and choose how to proceed.")
+        headline = ""
+        if outcome.diagnostic is not None:
+            headline = server_refusal_headline(outcome.server_refusals, outcome.diagnostic.stderr) or failure_headline(outcome.diagnostic, account)
+            details.append(failure_summary(outcome.diagnostic))
+        self.show_error("\n".join(details), headline)
+        self.push_button.setEnabled(False)
+
+    def browse(self) -> None:
+        """Open a nonblocking directory selector from the folder the typed Url stands for, ``~`` read where that is the usage.
+
+        A Url that is not an absolute folder leaves the selector at its own start folder; cancelling changes nothing.
+        """
+        self._open_folder_chooser(typed_start_dir(self.url_edit.text(), self.typed_path))
+
+    def _open_folder_chooser(self, start_dir: str) -> None:
+        """Open the directory selector at ``start_dir``, tied to the current draft lifetime; cancelling changes nothing."""
+        dialog = QFileDialog(self, "Choose Push repository", start_dir)
+        dialog.setFileMode(QFileDialog.FileMode.Directory)
+        def selected(filename: str) -> None:
+            """Keep the chosen directory in the draft without starting network work."""
+            if not self.closed:
+                self.url_edit.setText(filename)
+                self.destination_changed.emit()
+        dialog.fileSelected.connect(selected)
+        dialog.open()
+
+    def refresh_metrics(self, available_geometry: QRect | None = None) -> None:
+        """Fit the fields and permanent Push action within the available screen."""
+        fit_form(self, available_geometry)
+
+    def showEvent(self, event: QShowEvent) -> None:
+        """Apply current screen bounds without scaling logical coordinates twice."""
+        super().showEvent(event)
+        self.refresh_metrics()
+
+    def _closed(self) -> None:
+        """Invalidate pending reads and return keyboard focus to the live opener."""
+        self.closed = True
+        if self.return_focus is not None and isValid(self.return_focus):
+            self.return_focus.setFocus()