1349 lines
48 KiB
Python
1349 lines
48 KiB
Python
from __future__ import annotations
|
||
|
||
from concurrent.futures import Future, ThreadPoolExecutor
|
||
from dataclasses import dataclass, replace
|
||
import curses
|
||
import unicodedata
|
||
from typing import Callable, Iterable
|
||
|
||
from .aliases import MAX_ALIAS_LENGTH, normalize_alias
|
||
from .domain import is_valid_session_name
|
||
from .remotes import (
|
||
RegistryError,
|
||
RemoteEntry,
|
||
RemoteQueryPool,
|
||
RemoteQueryResult,
|
||
RemoteRegistry,
|
||
)
|
||
|
||
|
||
RenameHandler = Callable[[str, str], None]
|
||
|
||
|
||
@dataclass(frozen=True)
|
||
class DeleteSessionOutcome:
|
||
warning: str | None = None
|
||
windows: tuple["CatalogWindow", ...] | None = None
|
||
tab_closed: bool = False
|
||
|
||
|
||
def terminal_display_width(text: str) -> int:
|
||
"""Return the number of terminal cells occupied by Unicode text."""
|
||
width = 0
|
||
for character in text:
|
||
if unicodedata.combining(character):
|
||
continue
|
||
if unicodedata.category(character).startswith("C"):
|
||
continue
|
||
width += 2 if unicodedata.east_asian_width(character) in {"W", "F"} else 1
|
||
return width
|
||
|
||
|
||
def truncate_terminal_text(text: str, max_width: int) -> str:
|
||
if max_width <= 0:
|
||
return ""
|
||
result: list[str] = []
|
||
width = 0
|
||
for character in text:
|
||
character_width = terminal_display_width(character)
|
||
if width + character_width > max_width:
|
||
break
|
||
result.append(character)
|
||
width += character_width
|
||
return "".join(result)
|
||
|
||
|
||
def terminal_text_tail(text: str, max_width: int) -> str:
|
||
if max_width <= 0:
|
||
return ""
|
||
start = len(text)
|
||
width = 0
|
||
for index in range(len(text) - 1, -1, -1):
|
||
character_width = terminal_display_width(text[index])
|
||
if width + character_width > max_width:
|
||
break
|
||
start = index
|
||
width += character_width
|
||
return text[start:]
|
||
|
||
|
||
def pad_terminal_text(text: str, width: int) -> str:
|
||
truncated = truncate_terminal_text(text, width)
|
||
return truncated + " " * max(0, width - terminal_display_width(truncated))
|
||
|
||
|
||
def input_display_line(prompt: str, value: str, width: int) -> str:
|
||
prefix = f"{prompt}: "
|
||
if terminal_display_width(prefix) >= width:
|
||
return truncate_terminal_text(prefix, width)
|
||
value_width = width - terminal_display_width(prefix)
|
||
if terminal_display_width(value) <= value_width:
|
||
visible_value = value
|
||
elif value_width <= 1:
|
||
visible_value = "…"[:value_width]
|
||
else:
|
||
visible_value = "…" + terminal_text_tail(value, value_width - 1)
|
||
return prefix + visible_value
|
||
|
||
|
||
class SelectorError(RuntimeError):
|
||
"""The interactive selector could not be displayed."""
|
||
|
||
|
||
@dataclass(frozen=True)
|
||
class CatalogWindow:
|
||
window_id: str
|
||
key: str
|
||
label: str
|
||
dead: bool
|
||
active: bool
|
||
kind: str | None = None
|
||
target: str | None = None
|
||
session: str | None = None
|
||
default_label: str | None = None
|
||
remote_transport: str = "native"
|
||
|
||
|
||
@dataclass(frozen=True)
|
||
class StopSessionOutcome:
|
||
windows: tuple[CatalogWindow, ...]
|
||
tab_closed: bool = True
|
||
warning: str | None = None
|
||
|
||
|
||
DeleteSessionHandler = Callable[[str, str, str | None], DeleteSessionOutcome | None]
|
||
StopSessionHandler = Callable[[str, str, str], StopSessionOutcome | list[CatalogWindow]]
|
||
|
||
|
||
@dataclass(frozen=True)
|
||
class _PendingAction:
|
||
kind: str
|
||
target: str
|
||
session: str
|
||
window_id: str | None = None
|
||
|
||
|
||
@dataclass(frozen=True)
|
||
class SelectorResult:
|
||
kind: str
|
||
window_id: str | None = None
|
||
dead: bool = False
|
||
target: str | None = None
|
||
session: str | None = None
|
||
remote_keybindings: str = "local"
|
||
remote_transport: str = "native"
|
||
endpoint_key: str | None = None
|
||
alias: str | None = None
|
||
|
||
@classmethod
|
||
def window(cls, window_id: str, *, dead: bool) -> SelectorResult:
|
||
return cls(kind="window", window_id=window_id, dead=dead)
|
||
|
||
@classmethod
|
||
def close(cls, window_id: str) -> SelectorResult:
|
||
return cls(kind="close", window_id=window_id)
|
||
|
||
@classmethod
|
||
def local(cls, session: str) -> SelectorResult:
|
||
return cls(kind="local", session=session)
|
||
|
||
@classmethod
|
||
def rename(cls, endpoint_key: str, alias: str) -> SelectorResult:
|
||
return cls(kind="rename", endpoint_key=endpoint_key, alias=alias)
|
||
|
||
@classmethod
|
||
def remote(
|
||
cls,
|
||
target: str,
|
||
session: str,
|
||
remote_keybindings: str,
|
||
remote_transport: str = "native",
|
||
) -> SelectorResult:
|
||
return cls(
|
||
kind="remote",
|
||
target=target,
|
||
session=session,
|
||
remote_keybindings=remote_keybindings,
|
||
remote_transport=remote_transport,
|
||
)
|
||
|
||
|
||
@dataclass(frozen=True)
|
||
class PickerRow:
|
||
key: str
|
||
kind: str
|
||
main: str
|
||
detail: str = ""
|
||
selectable: bool = True
|
||
window_id: str | None = None
|
||
dead: bool = False
|
||
target: str | None = None
|
||
session: str | None = None
|
||
remote_keybindings: str = "local"
|
||
remote_transport: str = "native"
|
||
endpoint_key: str | None = None
|
||
deletable: bool = False
|
||
|
||
|
||
def build_main_rows(
|
||
windows: Iterable[CatalogWindow],
|
||
entries: Iterable[RemoteEntry],
|
||
results: dict[str, RemoteQueryResult],
|
||
loading_targets: set[str],
|
||
*,
|
||
local_sessions: Iterable[str] = (),
|
||
registry_error: str | None = None,
|
||
) -> list[PickerRow]:
|
||
window_list = list(windows)
|
||
entry_list = sorted(entries, key=lambda entry: entry.target)
|
||
registered = {entry.target for entry in entry_list}
|
||
rows: list[PickerRow] = []
|
||
|
||
standalone = [
|
||
window
|
||
for window in window_list
|
||
if window.kind == "local"
|
||
or window.target is None
|
||
or window.target not in registered
|
||
]
|
||
if standalone:
|
||
rows.append(PickerRow("heading:open", "heading", "已打开", selectable=False))
|
||
for window in standalone:
|
||
rows.append(_window_row(window))
|
||
|
||
open_local_sessions = {
|
||
window.session
|
||
for window in window_list
|
||
if window.kind == "local" and window.session is not None
|
||
}
|
||
available_local_sessions = sorted(
|
||
{
|
||
session
|
||
for session in local_sessions
|
||
if is_valid_session_name(session) and session not in open_local_sessions
|
||
},
|
||
key=lambda name: (name != "default", name),
|
||
)
|
||
if available_local_sessions:
|
||
rows.append(PickerRow("heading:local", "heading", "本机", selectable=False))
|
||
rows.extend(
|
||
PickerRow(
|
||
f"local:{session}",
|
||
"local",
|
||
f"○ {session}",
|
||
"未在 Tab 中 · 单击打开",
|
||
session=session,
|
||
)
|
||
for session in available_local_sessions
|
||
)
|
||
|
||
active_window = next((window for window in window_list if window.active), None)
|
||
if active_window is not None:
|
||
can_close = len(window_list) > 1
|
||
rows.append(
|
||
PickerRow(
|
||
"close-active",
|
||
"close",
|
||
f"− 关闭当前 Tab：{active_window.label}",
|
||
"Herdr Session 保持运行" if can_close else "至少保留一个 Session Tab",
|
||
selectable=can_close,
|
||
window_id=active_window.window_id,
|
||
)
|
||
)
|
||
if (
|
||
active_window.kind == "remote"
|
||
and active_window.target is not None
|
||
and active_window.session is not None
|
||
):
|
||
rows.append(
|
||
PickerRow(
|
||
"stop-active",
|
||
"stop-session",
|
||
f"■ 关闭并停止当前 Session：{active_window.label}",
|
||
(
|
||
"远端任务会中断"
|
||
if can_close
|
||
else "远端任务会中断；最后一个 Tab 将保留为断线状态"
|
||
),
|
||
selectable=True,
|
||
window_id=active_window.window_id,
|
||
target=active_window.target,
|
||
session=active_window.session,
|
||
)
|
||
)
|
||
if window_list:
|
||
rows.append(
|
||
PickerRow(
|
||
"manage-sessions",
|
||
"manage-sessions",
|
||
"✎ 管理 Session 显示名称…",
|
||
"重命名或恢复默认",
|
||
)
|
||
)
|
||
|
||
remote_windows = {
|
||
(window.target, window.session): window
|
||
for window in window_list
|
||
if window.kind == "remote"
|
||
and window.target is not None
|
||
and window.session is not None
|
||
}
|
||
for entry in entry_list:
|
||
result = results.get(entry.target)
|
||
preferred_transport = (
|
||
"ssh"
|
||
if entry.remote_transport == "ssh"
|
||
or (result is not None and result.platform == "windows")
|
||
or any(
|
||
window.target == entry.target and window.remote_transport == "ssh"
|
||
for window in window_list
|
||
)
|
||
else "native"
|
||
)
|
||
platform_detail = (
|
||
"Windows · SSH 模式"
|
||
if result is not None and result.platform == "windows"
|
||
else "SSH TTY 模式"
|
||
if preferred_transport == "ssh"
|
||
else "远端"
|
||
)
|
||
rows.append(
|
||
PickerRow(
|
||
f"heading:{entry.target}",
|
||
"heading",
|
||
entry.target,
|
||
platform_detail,
|
||
selectable=False,
|
||
)
|
||
)
|
||
session_by_name = (
|
||
{
|
||
session.name: session
|
||
for session in result.sessions
|
||
if is_valid_session_name(session.name)
|
||
}
|
||
if result is not None and result.error is None
|
||
else {}
|
||
)
|
||
for target, session_name in remote_windows:
|
||
if target == entry.target and session_name is not None:
|
||
session_by_name.setdefault(session_name, None)
|
||
|
||
for session_name in sorted(
|
||
session_by_name,
|
||
key=lambda name: (name != "default", name),
|
||
):
|
||
window = remote_windows.get((entry.target, session_name))
|
||
session = session_by_name[session_name]
|
||
if session is not None:
|
||
running = session.running
|
||
else:
|
||
assert window is not None
|
||
running = not window.dead
|
||
state_known = result is not None and result.error is None
|
||
deletable = state_known and not running and session_name != "default"
|
||
transport = preferred_transport
|
||
# Automatic transport reconciliation is intentionally one-way.
|
||
# A confirmed/manual SSH window must never be downgraded merely
|
||
# because platform detection is loading, failed or inconclusive.
|
||
if window is not None and not (
|
||
transport == "ssh" and window.remote_transport != "ssh"
|
||
):
|
||
row = _window_row(window)
|
||
if state_known and not running:
|
||
row = replace(
|
||
row,
|
||
detail=(
|
||
"已停止 · Enter 启动 · Herdr 保留 default"
|
||
if session_name == "default"
|
||
else "已停止 · Enter 启动 · d/D 删除（同时关闭 Tab）"
|
||
),
|
||
deletable=deletable,
|
||
)
|
||
rows.append(row)
|
||
continue
|
||
if window is not None and transport == "ssh":
|
||
symbol = "↻"
|
||
detail = "Windows · 切换为 SSH 模式"
|
||
else:
|
||
symbol = "○" if running else "■"
|
||
if transport == "ssh":
|
||
detail = (
|
||
"Windows · SSH 模式 · 单击打开"
|
||
if running
|
||
else "Windows · 已停止 · Enter 启动 · Herdr 保留 default"
|
||
if session_name == "default"
|
||
else "Windows · 已停止 · Enter 启动 · d/D 删除"
|
||
)
|
||
else:
|
||
detail = (
|
||
"远端运行 · 单击打开"
|
||
if running
|
||
else "已停止 · Enter 启动 · Herdr 保留 default"
|
||
if session_name == "default"
|
||
else "已停止 · Enter 启动 · d/D 删除"
|
||
)
|
||
rows.append(
|
||
PickerRow(
|
||
f"remote:{entry.target}:{session_name}",
|
||
"remote",
|
||
f"{symbol} {session_name}",
|
||
detail,
|
||
window_id=window.window_id if window is not None else None,
|
||
target=entry.target,
|
||
session=session_name,
|
||
remote_keybindings=entry.remote_keybindings,
|
||
remote_transport=transport,
|
||
deletable=deletable,
|
||
)
|
||
)
|
||
|
||
if entry.target in loading_targets:
|
||
rows.append(
|
||
PickerRow(
|
||
f"loading:{entry.target}",
|
||
"loading",
|
||
"… 正在查询 Sessions",
|
||
selectable=False,
|
||
)
|
||
)
|
||
elif result is not None and result.error is not None:
|
||
rows.append(
|
||
PickerRow(
|
||
f"retry:{entry.target}",
|
||
"retry",
|
||
"! 查询失败 · Enter 重试 · d/D 移除记录",
|
||
result.error,
|
||
target=entry.target,
|
||
)
|
||
)
|
||
elif result is not None and not session_by_name:
|
||
rows.append(
|
||
PickerRow(
|
||
f"empty:{entry.target}",
|
||
"empty",
|
||
"没有已有 Session",
|
||
selectable=False,
|
||
)
|
||
)
|
||
rows.append(
|
||
PickerRow(
|
||
f"new:{entry.target}",
|
||
"new",
|
||
"+ 新建 Session…",
|
||
entry.target,
|
||
target=entry.target,
|
||
remote_keybindings=entry.remote_keybindings,
|
||
remote_transport=preferred_transport,
|
||
)
|
||
)
|
||
|
||
if registry_error is not None:
|
||
rows.append(
|
||
PickerRow(
|
||
"registry-error",
|
||
"error",
|
||
"! 远端配置不可用",
|
||
registry_error,
|
||
selectable=False,
|
||
)
|
||
)
|
||
else:
|
||
rows.extend(
|
||
[
|
||
PickerRow("add-remote", "add", "+ 添加远端…", "自动/native 模式"),
|
||
PickerRow(
|
||
"add-ssh-remote",
|
||
"add-ssh",
|
||
"+ 添加 Windows/SSH 远端…",
|
||
"强制 SSH TTY 模式",
|
||
remote_transport="ssh",
|
||
),
|
||
PickerRow("manage-remotes", "manage", "⚙ 管理远端…"),
|
||
]
|
||
)
|
||
return rows
|
||
|
||
|
||
def _window_row(window: CatalogWindow) -> PickerRow:
|
||
symbol = "▶" if window.active else "×" if window.dead else "●"
|
||
detail = "当前" if window.active else "已断线 · 单击重连" if window.dead else "Hub 已打开"
|
||
return PickerRow(
|
||
f"window:{window.window_id}",
|
||
"window",
|
||
f"{symbol} {window.label}",
|
||
detail,
|
||
window_id=window.window_id,
|
||
dead=window.dead,
|
||
target=window.target,
|
||
session=window.session,
|
||
)
|
||
|
||
|
||
def filter_rows(rows: Iterable[PickerRow], query: str) -> list[PickerRow]:
|
||
if not query:
|
||
return list(rows)
|
||
needle = query.casefold()
|
||
return [
|
||
row
|
||
for row in rows
|
||
if needle in f"{row.main} {row.detail}".casefold()
|
||
]
|
||
|
||
|
||
class SessionSelector:
|
||
def __init__(
|
||
self,
|
||
windows: Iterable[CatalogWindow],
|
||
registry: RemoteRegistry,
|
||
ssh_bin: str,
|
||
local_sessions: Iterable[str] = (),
|
||
aliases: dict[str, str] | None = None,
|
||
rename_handler: RenameHandler | None = None,
|
||
delete_session_handler: DeleteSessionHandler | None = None,
|
||
stop_session_handler: StopSessionHandler | None = None,
|
||
) -> None:
|
||
self.windows = list(windows)
|
||
self.local_sessions = list(local_sessions)
|
||
self.aliases = dict(aliases or {})
|
||
self.rename_handler = rename_handler
|
||
self.delete_session_handler = delete_session_handler
|
||
self.stop_session_handler = stop_session_handler
|
||
self.registry = registry
|
||
self.pool = RemoteQueryPool(ssh_bin)
|
||
self.action_executor = ThreadPoolExecutor(
|
||
max_workers=1,
|
||
thread_name_prefix="herdr-hub-action",
|
||
)
|
||
self.action_future: Future[object] | None = None
|
||
self.pending_action: _PendingAction | None = None
|
||
self.entries: dict[str, RemoteEntry] = {}
|
||
self.results: dict[str, RemoteQueryResult] = {}
|
||
self.registry_error: str | None = None
|
||
self.message = ""
|
||
self.query = ""
|
||
self.selected_key: str | None = None
|
||
self.scroll = 0
|
||
self.view = "main"
|
||
self.input_value = ""
|
||
self.input_target: str | None = None
|
||
self.input_session: str | None = None
|
||
self.input_window_id: str | None = None
|
||
self.input_key: str | None = None
|
||
self.input_remote_keybindings = "local"
|
||
self.input_remote_transport = "native"
|
||
self._drawn_rows: dict[int, PickerRow] = {}
|
||
self._load_registry()
|
||
|
||
def _load_registry(self) -> None:
|
||
try:
|
||
entries = self.registry.load()
|
||
except RegistryError as error:
|
||
self.registry_error = str(error)
|
||
return
|
||
self.registry_error = None
|
||
self.entries = {entry.target: entry for entry in entries}
|
||
self.pool.enqueue_many(entries)
|
||
|
||
def run(self) -> SelectorResult | None:
|
||
try:
|
||
return curses.wrapper(self._curses_main)
|
||
except curses.error as error:
|
||
raise SelectorError(f"could not initialize the terminal selector: {error}") from error
|
||
finally:
|
||
self.pool.close()
|
||
self.action_executor.shutdown(wait=False, cancel_futures=True)
|
||
|
||
def _curses_main(self, screen) -> SelectorResult | None: # type: ignore[no-untyped-def]
|
||
screen.keypad(True)
|
||
screen.timeout(100)
|
||
try:
|
||
curses.curs_set(0)
|
||
except curses.error:
|
||
pass
|
||
try:
|
||
curses.use_default_colors()
|
||
except curses.error:
|
||
pass
|
||
curses.mouseinterval(150)
|
||
curses.mousemask(curses.ALL_MOUSE_EVENTS)
|
||
|
||
while True:
|
||
for result in self.pool.poll():
|
||
self.results[result.entry.target] = result
|
||
self._poll_action()
|
||
rows = self._rows()
|
||
filtered = filter_rows(rows, self.query) if self.view == "main" else rows
|
||
self._normalize_selection(filtered)
|
||
self._draw(screen, filtered)
|
||
try:
|
||
key = screen.get_wch()
|
||
except curses.error:
|
||
continue
|
||
|
||
outcome = self._handle_key(key, filtered)
|
||
if isinstance(outcome, SelectorResult) or outcome is False:
|
||
return outcome if isinstance(outcome, SelectorResult) else None
|
||
|
||
def _rows(self) -> list[PickerRow]:
|
||
if self.view == "manage-sessions":
|
||
rows = [
|
||
PickerRow(
|
||
"manage-sessions-heading",
|
||
"heading",
|
||
"管理 Session 显示名称",
|
||
"仅影响 Hub，不修改底层 Session ID",
|
||
selectable=False,
|
||
)
|
||
]
|
||
rows.extend(
|
||
PickerRow(
|
||
f"rename:{window.key}",
|
||
"rename",
|
||
f"✎ {window.label}",
|
||
(
|
||
f"原名 {window.default_label}"
|
||
if window.key in self.aliases
|
||
else "使用默认名称"
|
||
),
|
||
endpoint_key=window.key,
|
||
)
|
||
for window in sorted(
|
||
self.windows,
|
||
key=lambda item: (not item.active, item.label.casefold()),
|
||
)
|
||
)
|
||
rows.append(PickerRow("manage-sessions-back", "back", "← 返回 Sessions"))
|
||
return rows
|
||
if self.view == "manage":
|
||
rows = [PickerRow("manage-heading", "heading", "管理远端", selectable=False)]
|
||
rows.extend(
|
||
PickerRow(
|
||
f"remove:{entry.target}",
|
||
"remove",
|
||
f"− {entry.target}",
|
||
(
|
||
"SSH TTY · 单击后确认移除"
|
||
if entry.remote_transport == "ssh"
|
||
else "native/自动 · 单击后确认移除"
|
||
),
|
||
target=entry.target,
|
||
)
|
||
for entry in sorted(self.entries.values(), key=lambda item: item.target)
|
||
)
|
||
if len(rows) == 1:
|
||
rows.append(PickerRow("no-remotes", "empty", "没有已登记远端", selectable=False))
|
||
rows.append(PickerRow("manage-back", "back", "← 返回 Sessions"))
|
||
return rows
|
||
if self.view == "confirm-remove":
|
||
target = self.input_target or ""
|
||
return [
|
||
PickerRow(
|
||
"confirm-heading",
|
||
"heading",
|
||
f"移除 {target}？",
|
||
"不会关闭已有窗口或远端 server",
|
||
selectable=False,
|
||
),
|
||
PickerRow("confirm-yes", "confirm-yes", "移除", target=target),
|
||
PickerRow("confirm-no", "back", "取消"),
|
||
]
|
||
if self.view == "confirm-delete-session":
|
||
target = self.input_target or ""
|
||
session = self.input_session or ""
|
||
return [
|
||
PickerRow(
|
||
"delete-session-heading",
|
||
"heading",
|
||
f"永久删除 {target}/{session}？",
|
||
(
|
||
"关联 Hub Tab 也会关闭"
|
||
if self.input_window_id is not None
|
||
else "Session 已停止"
|
||
),
|
||
selectable=False,
|
||
),
|
||
PickerRow(
|
||
"delete-session-warning",
|
||
"empty",
|
||
"工作现场和历史数据将无法恢复",
|
||
selectable=False,
|
||
),
|
||
PickerRow(
|
||
"delete-session-yes",
|
||
"delete-session-yes",
|
||
"确认删除",
|
||
window_id=self.input_window_id,
|
||
target=target,
|
||
session=session,
|
||
),
|
||
PickerRow("delete-session-no", "back", "取消"),
|
||
]
|
||
if self.view == "confirm-stop-session":
|
||
target = self.input_target or ""
|
||
session = self.input_session or ""
|
||
closes_tab = len(self.windows) > 1
|
||
return [
|
||
PickerRow(
|
||
"stop-session-heading",
|
||
"heading",
|
||
f"关闭并停止 {target}/{session}？",
|
||
(
|
||
"Hub Tab 将关闭，远端任务会中断"
|
||
if closes_tab
|
||
else "最后一个 Tab 将保留为断线状态，远端任务会中断"
|
||
),
|
||
selectable=False,
|
||
),
|
||
PickerRow(
|
||
"stop-session-yes",
|
||
"stop-session-yes",
|
||
"确认停止",
|
||
window_id=self.input_window_id,
|
||
target=target,
|
||
session=session,
|
||
),
|
||
PickerRow("stop-session-no", "back", "取消"),
|
||
]
|
||
if self.view in {"working-delete-session", "working-stop-session"}:
|
||
action = self.pending_action
|
||
target = action.target if action is not None else ""
|
||
session = action.session if action is not None else ""
|
||
verb = "删除" if self.view == "working-delete-session" else "停止"
|
||
return [
|
||
PickerRow(
|
||
"working-heading",
|
||
"heading",
|
||
f"正在{verb} {target}/{session}",
|
||
"SSH 操作进行中，请稍候…",
|
||
selectable=False,
|
||
)
|
||
]
|
||
if self.view in {"input-add", "input-new", "input-rename"}:
|
||
return []
|
||
return build_main_rows(
|
||
self.windows,
|
||
self.entries.values(),
|
||
self.results,
|
||
{target for target in self.entries if self.pool.is_loading(target)},
|
||
local_sessions=self.local_sessions,
|
||
registry_error=self.registry_error,
|
||
)
|
||
|
||
def _handle_key(self, key, rows: list[PickerRow]): # type: ignore[no-untyped-def]
|
||
if self.action_future is not None:
|
||
if key == "\x1b":
|
||
self.message = "远端操作正在进行，完成后可继续管理"
|
||
return None
|
||
if self.view in {"input-add", "input-new", "input-rename"}:
|
||
return self._handle_input_key(key)
|
||
if key == curses.KEY_MOUSE:
|
||
return self._handle_mouse(rows)
|
||
if key in {curses.KEY_UP}:
|
||
self._move(rows, -1)
|
||
return None
|
||
if key in {curses.KEY_DOWN}:
|
||
self._move(rows, 1)
|
||
return None
|
||
if key == curses.KEY_PPAGE:
|
||
self._move(rows, -8)
|
||
return None
|
||
if key == curses.KEY_NPAGE:
|
||
self._move(rows, 8)
|
||
return None
|
||
if key in {curses.KEY_ENTER, "\n", "\r"}:
|
||
return self._activate(self._selected_row(rows))
|
||
if key in {"d", "D"} and self.view == "confirm-delete-session":
|
||
row = next(
|
||
(item for item in rows if item.kind == "delete-session-yes"),
|
||
None,
|
||
)
|
||
return self._activate(row)
|
||
if key in {"d", "D"} and self.view == "confirm-remove":
|
||
row = next(
|
||
(item for item in rows if item.kind == "confirm-yes"),
|
||
None,
|
||
)
|
||
return self._activate(row)
|
||
if key in {"d", "D"} and self.view == "main":
|
||
row = self._selected_row(rows)
|
||
if row is not None and row.deletable:
|
||
self._show_delete_session_confirmation(row)
|
||
return None
|
||
if row is not None and row.kind == "retry" and row.target is not None:
|
||
self._show_remove_confirmation(row.target)
|
||
return None
|
||
if row is not None and row.target is not None and row.session == "default":
|
||
self.message = "Herdr 不支持删除 default Session"
|
||
else:
|
||
self.message = "只能删除已停止的远端 Session"
|
||
return None
|
||
if key == "\x12" and self.view == "main":
|
||
self.results.clear()
|
||
self.pool.enqueue_many(self.entries.values())
|
||
self.message = "正在刷新所有远端"
|
||
return None
|
||
if key == "\x1b":
|
||
if self.view != "main":
|
||
self._show_main()
|
||
return None
|
||
if self.query:
|
||
self.query = ""
|
||
self.selected_key = None
|
||
return None
|
||
return False
|
||
if key in {curses.KEY_BACKSPACE, "\x7f", "\b"} and self.view == "main":
|
||
self.query = self.query[:-1]
|
||
self.selected_key = None
|
||
return None
|
||
if isinstance(key, str) and key.isprintable() and self.view == "main":
|
||
if len(self.query) < 128:
|
||
self.query += key
|
||
self.selected_key = None
|
||
return None
|
||
return None
|
||
|
||
def _handle_input_key(self, key): # type: ignore[no-untyped-def]
|
||
if key == "\x1b":
|
||
if self.view == "input-rename":
|
||
self._show_manage_sessions()
|
||
return None
|
||
self._show_main()
|
||
return None
|
||
if key in {curses.KEY_ENTER, "\n", "\r"}:
|
||
value = self.input_value.strip()
|
||
if self.view == "input-add":
|
||
return self._finish_add(value)
|
||
if self.view == "input-rename":
|
||
return self._finish_rename(value)
|
||
return self._finish_new(value)
|
||
if key == "\x15" and self.view == "input-rename":
|
||
self.input_value = ""
|
||
return None
|
||
if key in {curses.KEY_BACKSPACE, "\x7f", "\b"}:
|
||
self.input_value = self.input_value[:-1]
|
||
return None
|
||
limit = MAX_ALIAS_LENGTH if self.view == "input-rename" else 512
|
||
if isinstance(key, str) and key.isprintable() and len(self.input_value) < limit:
|
||
self.input_value += key
|
||
return None
|
||
|
||
def _handle_mouse(self, rows: list[PickerRow]):
|
||
try:
|
||
_, _, y, _, state = curses.getmouse()
|
||
except curses.error:
|
||
return None
|
||
if state & getattr(curses, "BUTTON4_PRESSED", 0):
|
||
self._move(rows, -3)
|
||
return None
|
||
if state & getattr(curses, "BUTTON5_PRESSED", 0):
|
||
self._move(rows, 3)
|
||
return None
|
||
activated = (
|
||
getattr(curses, "BUTTON1_RELEASED", 0)
|
||
| getattr(curses, "BUTTON1_CLICKED", 0)
|
||
| getattr(curses, "BUTTON1_DOUBLE_CLICKED", 0)
|
||
)
|
||
if state & activated:
|
||
row = self._drawn_rows.get(y)
|
||
if row is not None and row.selectable:
|
||
self.selected_key = row.key
|
||
return self._activate(row)
|
||
return None
|
||
|
||
def _activate(self, row: PickerRow | None):
|
||
if row is None:
|
||
return None
|
||
if row.kind == "window":
|
||
assert row.window_id is not None
|
||
return SelectorResult.window(row.window_id, dead=row.dead)
|
||
if row.kind == "close":
|
||
assert row.window_id is not None
|
||
return SelectorResult.close(row.window_id)
|
||
if row.kind == "local":
|
||
assert row.session is not None
|
||
return SelectorResult.local(row.session)
|
||
if row.kind == "remote":
|
||
assert row.target is not None and row.session is not None
|
||
return SelectorResult.remote(
|
||
row.target,
|
||
row.session,
|
||
row.remote_keybindings,
|
||
row.remote_transport,
|
||
)
|
||
if row.kind == "retry":
|
||
assert row.target is not None
|
||
self.results.pop(row.target, None)
|
||
self.pool.enqueue(self.entries[row.target])
|
||
self.message = f"正在重试 {row.target}"
|
||
elif row.kind == "new":
|
||
self.view = "input-new"
|
||
self.input_target = row.target
|
||
self.input_remote_keybindings = row.remote_keybindings
|
||
self.input_remote_transport = row.remote_transport
|
||
self.input_value = ""
|
||
self.message = ""
|
||
elif row.kind in {"add", "add-ssh"}:
|
||
self.view = "input-add"
|
||
self.input_target = None
|
||
self.input_remote_keybindings = "local"
|
||
self.input_remote_transport = row.remote_transport
|
||
self.input_value = ""
|
||
self.message = ""
|
||
elif row.kind == "manage":
|
||
self.view = "manage"
|
||
self.query = ""
|
||
self.selected_key = None
|
||
elif row.kind == "manage-sessions":
|
||
self._show_manage_sessions()
|
||
elif row.kind == "rename":
|
||
assert row.endpoint_key is not None
|
||
self.view = "input-rename"
|
||
self.input_key = row.endpoint_key
|
||
self.input_target = next(
|
||
(
|
||
window.default_label
|
||
for window in self.windows
|
||
if window.key == row.endpoint_key
|
||
),
|
||
row.endpoint_key,
|
||
)
|
||
self.input_value = self.aliases.get(row.endpoint_key, "")
|
||
self.message = ""
|
||
elif row.kind == "remove":
|
||
assert row.target is not None
|
||
self._show_remove_confirmation(row.target)
|
||
elif row.kind == "stop-session":
|
||
assert (
|
||
row.window_id is not None
|
||
and row.target is not None
|
||
and row.session is not None
|
||
)
|
||
self.view = "confirm-stop-session"
|
||
self.input_window_id = row.window_id
|
||
self.input_target = row.target
|
||
self.input_session = row.session
|
||
self.selected_key = "stop-session-no"
|
||
self.message = ""
|
||
elif row.kind == "confirm-yes":
|
||
self._finish_remove(row.target or "")
|
||
elif row.kind == "delete-session-yes":
|
||
self._finish_delete_session(
|
||
row.target or "",
|
||
row.session or "",
|
||
row.window_id,
|
||
)
|
||
elif row.kind == "stop-session-yes":
|
||
self._finish_stop_session(
|
||
row.window_id or "",
|
||
row.target or "",
|
||
row.session or "",
|
||
)
|
||
elif row.kind == "back":
|
||
self._show_main()
|
||
return None
|
||
|
||
def _finish_add(self, target: str):
|
||
try:
|
||
entry = RemoteEntry(
|
||
target,
|
||
self.input_remote_keybindings,
|
||
self.input_remote_transport,
|
||
)
|
||
self.registry.upsert(entry)
|
||
except (ValueError, RegistryError) as error:
|
||
self.message = str(error)
|
||
return None
|
||
self.entries[target] = entry
|
||
self.results.pop(target, None)
|
||
self.pool.enqueue(entry)
|
||
self._show_main()
|
||
self.message = f"已添加 {target}，正在查询"
|
||
return None
|
||
|
||
def _finish_new(self, session: str):
|
||
if not is_valid_session_name(session):
|
||
self.message = "Session 名称需为 1-64 位字母、数字、. _ -"
|
||
return None
|
||
target = self.input_target
|
||
assert target is not None
|
||
entry = self.entries[target]
|
||
return SelectorResult.remote(
|
||
target,
|
||
session,
|
||
entry.remote_keybindings,
|
||
self.input_remote_transport,
|
||
)
|
||
|
||
def _finish_rename(self, alias: str):
|
||
try:
|
||
normalized = normalize_alias(alias)
|
||
except ValueError as error:
|
||
self.message = str(error)
|
||
return None
|
||
assert self.input_key is not None
|
||
if self.rename_handler is not None:
|
||
try:
|
||
self.rename_handler(self.input_key, normalized)
|
||
except (OSError, RuntimeError, ValueError) as error:
|
||
self.message = str(error)
|
||
return None
|
||
|
||
endpoint_key = self.input_key
|
||
if normalized:
|
||
self.aliases[endpoint_key] = normalized
|
||
else:
|
||
self.aliases.pop(endpoint_key, None)
|
||
display_label = normalized
|
||
updated_windows: list[CatalogWindow] = []
|
||
for window in self.windows:
|
||
if window.key == endpoint_key:
|
||
display_label = normalized or window.default_label or window.label
|
||
window = replace(window, label=display_label)
|
||
updated_windows.append(window)
|
||
self.windows = updated_windows
|
||
self._show_manage_sessions(selected_key=f"rename:{endpoint_key}")
|
||
self.message = (
|
||
f"已保存：{display_label}"
|
||
if normalized
|
||
else f"已恢复默认名称：{display_label}"
|
||
)
|
||
return None
|
||
return SelectorResult.rename(self.input_key, normalized)
|
||
|
||
def _show_delete_session_confirmation(self, row: PickerRow) -> None:
|
||
assert row.deletable and row.target is not None and row.session is not None
|
||
self.view = "confirm-delete-session"
|
||
self.input_target = row.target
|
||
self.input_session = row.session
|
||
self.input_window_id = row.window_id
|
||
self.selected_key = "delete-session-no"
|
||
self.message = ""
|
||
|
||
def _show_remove_confirmation(self, target: str) -> None:
|
||
self.view = "confirm-remove"
|
||
self.input_target = target
|
||
self.selected_key = "confirm-no"
|
||
self.message = ""
|
||
|
||
def _finish_delete_session(
|
||
self,
|
||
target: str,
|
||
session: str,
|
||
window_id: str | None = None,
|
||
) -> None:
|
||
if self.delete_session_handler is None:
|
||
self.message = "Session 删除功能不可用"
|
||
return
|
||
self.pending_action = _PendingAction("delete", target, session, window_id)
|
||
self.view = "working-delete-session"
|
||
self.selected_key = None
|
||
self.message = "正在通过 SSH 永久删除 Session…"
|
||
self.action_future = self.action_executor.submit(
|
||
self.delete_session_handler,
|
||
target,
|
||
session,
|
||
window_id,
|
||
)
|
||
|
||
def _finish_stop_session(
|
||
self,
|
||
window_id: str,
|
||
target: str,
|
||
session: str,
|
||
) -> None:
|
||
if self.stop_session_handler is None:
|
||
self.message = "Session 停止功能不可用"
|
||
return
|
||
self.pending_action = _PendingAction("stop", target, session, window_id)
|
||
self.view = "working-stop-session"
|
||
self.selected_key = None
|
||
self.message = "正在停止远端 Session…"
|
||
self.action_future = self.action_executor.submit(
|
||
self.stop_session_handler,
|
||
window_id,
|
||
target,
|
||
session,
|
||
)
|
||
|
||
def _poll_action(self) -> None:
|
||
future = self.action_future
|
||
action = self.pending_action
|
||
if future is None or action is None or not future.done():
|
||
return
|
||
self.action_future = None
|
||
self.pending_action = None
|
||
try:
|
||
outcome = future.result()
|
||
except (OSError, RuntimeError, ValueError) as error:
|
||
self._show_main()
|
||
entry = self.entries.get(action.target)
|
||
if entry is not None:
|
||
self.pool.enqueue(entry)
|
||
self.message = f"{action.target}/{action.session} 操作失败：{error}"
|
||
return
|
||
|
||
if action.kind == "delete":
|
||
delete_outcome = (
|
||
outcome
|
||
if isinstance(outcome, DeleteSessionOutcome)
|
||
else DeleteSessionOutcome()
|
||
)
|
||
if delete_outcome.windows is not None:
|
||
self.windows = list(delete_outcome.windows)
|
||
result = self.results.get(action.target)
|
||
if result is not None:
|
||
self.results[action.target] = replace(
|
||
result,
|
||
sessions=tuple(
|
||
item
|
||
for item in result.sessions
|
||
if item.name != action.session
|
||
),
|
||
)
|
||
warning = delete_outcome.warning
|
||
message = (
|
||
f"已关闭 Tab 并删除历史 Session：{action.target}/{action.session}"
|
||
if delete_outcome.tab_closed
|
||
else f"已删除历史 Session：{action.target}/{action.session}"
|
||
)
|
||
else:
|
||
stop_outcome = (
|
||
outcome
|
||
if isinstance(outcome, StopSessionOutcome)
|
||
else StopSessionOutcome(tuple(outcome))
|
||
)
|
||
self.windows = list(stop_outcome.windows)
|
||
result = self.results.get(action.target)
|
||
if result is not None:
|
||
self.results[action.target] = replace(
|
||
result,
|
||
sessions=tuple(
|
||
replace(item, running=False)
|
||
if item.name == action.session
|
||
else item
|
||
for item in result.sessions
|
||
),
|
||
)
|
||
warning = stop_outcome.warning
|
||
message = (
|
||
f"已关闭 Tab 并停止远端 Session：{action.target}/{action.session}"
|
||
if stop_outcome.tab_closed
|
||
else f"已停止远端 Session：{action.target}/{action.session}"
|
||
)
|
||
|
||
entry = self.entries.get(action.target)
|
||
if entry is not None:
|
||
self.pool.enqueue(entry)
|
||
self._show_main()
|
||
self.message = f"{message}；{warning}" if warning else message
|
||
|
||
def _finish_remove(self, target: str) -> None:
|
||
try:
|
||
self.registry.remove(target)
|
||
except RegistryError as error:
|
||
self.message = str(error)
|
||
self._show_main()
|
||
return
|
||
self.pool.cancel(target)
|
||
self.entries.pop(target, None)
|
||
self.results.pop(target, None)
|
||
self._show_main()
|
||
self.message = f"已移除 {target}；已有 window 保持不变"
|
||
|
||
def _show_main(self) -> None:
|
||
self.view = "main"
|
||
self.input_target = None
|
||
self.input_session = None
|
||
self.input_window_id = None
|
||
self.input_value = ""
|
||
self.input_key = None
|
||
self.input_remote_keybindings = "local"
|
||
self.input_remote_transport = "native"
|
||
self.selected_key = None
|
||
self.scroll = 0
|
||
|
||
def _show_manage_sessions(self, selected_key: str | None = None) -> None:
|
||
self.view = "manage-sessions"
|
||
self.input_target = None
|
||
self.input_session = None
|
||
self.input_window_id = None
|
||
self.input_value = ""
|
||
self.input_key = None
|
||
self.input_remote_keybindings = "local"
|
||
self.input_remote_transport = "native"
|
||
self.selected_key = selected_key
|
||
self.scroll = 0
|
||
|
||
def _normalize_selection(self, rows: list[PickerRow]) -> None:
|
||
selectable = [row for row in rows if row.selectable]
|
||
if not selectable:
|
||
self.selected_key = None
|
||
self.scroll = 0
|
||
return
|
||
if self.selected_key not in {row.key for row in selectable}:
|
||
self.selected_key = selectable[0].key
|
||
|
||
def _selected_row(self, rows: list[PickerRow]) -> PickerRow | None:
|
||
return next((row for row in rows if row.key == self.selected_key), None)
|
||
|
||
def _move(self, rows: list[PickerRow], delta: int) -> None:
|
||
selectable = [row for row in rows if row.selectable]
|
||
if not selectable:
|
||
return
|
||
current = next(
|
||
(index for index, row in enumerate(selectable) if row.key == self.selected_key),
|
||
0,
|
||
)
|
||
next_index = max(0, min(len(selectable) - 1, current + delta))
|
||
self.selected_key = selectable[next_index].key
|
||
|
||
def _draw(self, screen, rows: list[PickerRow]) -> None: # type: ignore[no-untyped-def]
|
||
screen.erase()
|
||
height, width = screen.getmaxyx()
|
||
self._drawn_rows = {}
|
||
if height < 8 or width < 28:
|
||
self._safe_add(screen, 0, 0, "终端太小，请旋转屏幕", curses.A_BOLD)
|
||
screen.refresh()
|
||
return
|
||
|
||
if self.view in {"input-add", "input-new", "input-rename"}:
|
||
self._draw_input(screen, height, width)
|
||
return
|
||
try:
|
||
curses.curs_set(0)
|
||
except curses.error:
|
||
pass
|
||
|
||
title = {
|
||
"main": "Sessions",
|
||
"manage-sessions": "管理 Session 显示名称",
|
||
"confirm-delete-session": "删除历史 Session",
|
||
"confirm-stop-session": "关闭并停止远端 Session",
|
||
"working-delete-session": "删除历史 Session",
|
||
"working-stop-session": "停止远端 Session",
|
||
}.get(self.view, "管理远端")
|
||
self._safe_add(screen, 1, 2, title, curses.A_BOLD)
|
||
if self.view == "main":
|
||
self._safe_add(screen, 2, 2, f"搜索: {self.query}", curses.A_DIM)
|
||
if self.message:
|
||
self._safe_add(screen, 3, 2, self.message, curses.A_DIM)
|
||
|
||
list_top = 4
|
||
list_height = max(1, height - list_top - 2)
|
||
selected_index = next(
|
||
(index for index, row in enumerate(rows) if row.key == self.selected_key),
|
||
0,
|
||
)
|
||
if selected_index < self.scroll:
|
||
self.scroll = selected_index
|
||
elif selected_index >= self.scroll + list_height:
|
||
self.scroll = selected_index - list_height + 1
|
||
self.scroll = max(0, min(self.scroll, max(0, len(rows) - list_height)))
|
||
|
||
for offset, row in enumerate(rows[self.scroll : self.scroll + list_height]):
|
||
y = list_top + offset
|
||
self._drawn_rows[y] = row
|
||
selected = row.key == self.selected_key
|
||
attribute = curses.A_REVERSE if selected else curses.A_NORMAL
|
||
if row.kind == "heading":
|
||
attribute |= curses.A_BOLD
|
||
elif not row.selectable:
|
||
attribute |= curses.A_DIM
|
||
detail_room = max(0, width // 2 - 2)
|
||
main_room = max(8, width - detail_room - 6)
|
||
main = pad_terminal_text(row.main, main_room)
|
||
detail = truncate_terminal_text(row.detail, detail_room)
|
||
line = f" {main} {detail}"
|
||
self._safe_add(screen, y, 0, line, attribute)
|
||
|
||
footer = "Enter 打开/重试 · d/D 删除/移除 · Ctrl+R 刷新 · Esc 关闭"
|
||
if self.view in {"working-delete-session", "working-stop-session"}:
|
||
footer = "远端操作进行中，请稍候"
|
||
elif self.view != "main":
|
||
footer = "单击/Enter 选择 · Esc 返回"
|
||
self._safe_add(screen, height - 1, 1, footer, curses.A_DIM)
|
||
screen.refresh()
|
||
|
||
def _draw_input(self, screen, height: int, width: int) -> None: # type: ignore[no-untyped-def]
|
||
if self.view == "input-rename":
|
||
remaining = MAX_ALIAS_LENGTH - len(self.input_value)
|
||
self._safe_add(screen, 1, 2, "修改 Hub 显示名称", curses.A_BOLD)
|
||
self._safe_add(
|
||
screen,
|
||
2,
|
||
2,
|
||
f"底层 Session：{self.input_target}",
|
||
curses.A_DIM,
|
||
)
|
||
prompt = f"显示名称（剩余 {remaining} 字符）"
|
||
input_line = input_display_line(prompt, self.input_value, width - 3)
|
||
self._safe_add(screen, 4, 2, input_line)
|
||
self._safe_add(
|
||
screen,
|
||
5,
|
||
2,
|
||
"留空并确认可恢复默认名称；不会修改底层 Session ID",
|
||
curses.A_DIM,
|
||
)
|
||
if self.message:
|
||
self._safe_add(screen, 6, 2, self.message, curses.A_DIM)
|
||
self._safe_add(
|
||
screen,
|
||
height - 1,
|
||
1,
|
||
"Enter 保存 · Ctrl+U 清空 · Esc 返回",
|
||
curses.A_DIM,
|
||
)
|
||
try:
|
||
curses.curs_set(1)
|
||
screen.move(
|
||
4,
|
||
min(width - 2, 2 + terminal_display_width(input_line)),
|
||
)
|
||
except curses.error:
|
||
pass
|
||
screen.refresh()
|
||
return
|
||
is_add = self.view == "input-add"
|
||
title = (
|
||
"添加 Windows/SSH 远端"
|
||
if is_add and self.input_remote_transport == "ssh"
|
||
else "添加远端"
|
||
if is_add
|
||
else f"在 {self.input_target} 新建 Session"
|
||
)
|
||
prompt = "SSH target" if is_add else "Session 名称"
|
||
self._safe_add(screen, 1, 2, title, curses.A_BOLD)
|
||
input_line = input_display_line(prompt, self.input_value, width - 3)
|
||
self._safe_add(screen, 3, 2, input_line)
|
||
if self.message:
|
||
self._safe_add(screen, 5, 2, self.message, curses.A_DIM)
|
||
self._safe_add(screen, height - 1, 1, "Enter 确认 · Esc 返回", curses.A_DIM)
|
||
try:
|
||
curses.curs_set(1)
|
||
screen.move(
|
||
3,
|
||
min(width - 2, 2 + terminal_display_width(input_line)),
|
||
)
|
||
except curses.error:
|
||
pass
|
||
screen.refresh()
|
||
|
||
@staticmethod
|
||
def _safe_add( # type: ignore[no-untyped-def]
|
||
screen,
|
||
y: int,
|
||
x: int,
|
||
text: str,
|
||
attribute: int = curses.A_NORMAL,
|
||
) -> None:
|
||
height, width = screen.getmaxyx()
|
||
if y < 0 or y >= height or x >= width:
|
||
return
|
||
try:
|
||
visible = truncate_terminal_text(text, max(0, width - x - 1))
|
||
screen.addstr(y, x, visible, attribute)
|
||
except curses.error:
|
||
pass
|