Add manual IP/port input for sending files

Users can now send files by entering a peer's IP address (IPv4/IPv6, optional port) directly, even if no peers are discovered. The CLI, language messages, and documentation have been updated to reflect this feature. Peer IDs are cached for manual targets to improve future transfers. Version bumped to 0.1.12.

Author: scarletkc

README.md

@@ -75,7 +75,7 @@ Requirements: install [deps](https://github.com/scarletkc/glitter/blob/main/requ
 ## Usage
 
 - [1] List peers: Show online devices (name/IP/version)
-- [2] Send file: Select a peer and input a path (quotes are allowed)
+- [2] Send file: Select a peer or enter an IP(v4/v6:port) and input a path (quotes are allowed)
 - [3] Incoming requests: Review transfer requests; Accept/Decline and choose a save directory
 - [4] Check updates: Open‑source repo link and latest version info
 - [5] History: Show the latest transfer records

docs/README.zh-CN.md

@@ -75,7 +75,7 @@ Glitter 提供了一个**简洁、基于终端**的替代方案，相比 GUI 工
 ## 用法
 
 - [1] 查看在线客户端：显示名称/IP/版本
-- [2] 发送文件：选择目标并输入路径（支持带引号）
+- [2] 发送文件：输入客户端编号或 IP 地址（支持 IPv4/IPv6，可选端口），再输入路径（支持带引号）
 - [3] 待处理请求：接收端确认/拒绝，并可选择保存目录
 - [4] 查看更新：显示当前版本与最新版本（需联网），并提供项目地址
 - [5] 传输记录：查看最近记录

glitter/__init__.py

@@ -4,5 +4,5 @@
 
 __all__ = ["__version__"]
 
-__version__ = "0.1.11"
+__version__ = "0.1.12"
 

glitter/cli.py

@@ -4,6 +4,7 @@
 
 from __future__ import annotations
 
+import ipaddress
 import os
 import re
 import sys
@@ -132,6 +133,8 @@ def __init__(
         self.ui = ui or TerminalUI()
         self._identity_public = identity_public or b""
         self._trust_store = trust_store
+        self._manual_peer_ids: dict[str, str] = {}
+        self._manual_peer_lock = threading.Lock()
 
         if isinstance(transfer_port, int) and 1 <= transfer_port <= 65535:
             preferred_port = transfer_port
@@ -189,6 +192,16 @@ def should_show_local_fingerprint(self, peer: PeerInfo) -> bool:
             return True
         return self._trust_store.get(peer_id) is None
 
+    def cached_peer_id_for_ip(self, ip: str) -> Optional[str]:
+        with self._manual_peer_lock:
+            return self._manual_peer_ids.get(ip)
+
+    def remember_peer_id_for_ip(self, ip: str, peer_id: str) -> None:
+        if not peer_id:
+            return
+        with self._manual_peer_lock:
+            self._manual_peer_ids[ip] = peer_id
+
     def clear_trusted_fingerprints(self) -> bool:
         if not self._trust_store:
             return False
@@ -276,7 +289,7 @@ def send_file(
         file_path: Path,
         progress_cb: Optional[Callable[[int, int], None]] = None,
         cancel_event: Optional[threading.Event] = None,
-    ) -> tuple[str, str]:
+    ) -> tuple[str, str, Optional[str]]:
         return self._transfer_service.send_file(
             peer.ip,
             peer.transfer_port,
@@ -508,24 +521,118 @@ def list_peers_cli(ui: TerminalUI, app: GlitterApp, language: str) -> None:
 
 def send_file_cli(ui: TerminalUI, app: GlitterApp, language: str) -> None:
     peers = app.list_peers()
-    if not peers:
+    default_port = app.transfer_port
+    if peers:
+        list_peers_cli(ui, app, language)
+    else:
         ui.print(get_message("no_peers", language))
-        return
-    list_peers_cli(ui, app, language)
+        ui.print(get_message("manual_target_hint", language))
+    ui.blank()
+
+    def parse_manual_target(raw: str) -> Optional[dict[str, object]]:
+        """Validate manual IPv4/IPv6 input and optional port."""
+        text = raw.strip()
+        if not text:
+            return None
+        port = default_port
+        normalized_ip: Optional[str] = None
+        if text.startswith("["):
+            closing = text.find("]")
+            if closing == -1:
+                return None
+            host_part = text[1:closing].strip()
+            remainder = text[closing + 1 :].strip()
+            if remainder:
+                if not remainder.startswith(":"):
+                    return None
+                port_text = remainder[1:].strip()
+                if not port_text.isdigit():
+                    return None
+                port = int(port_text)
+            try:
+                normalized_ip = ipaddress.ip_address(host_part).compressed
+            except ValueError:
+                return None
+            if not (1 <= port <= 65535):
+                return None
+            return {
+                "ip": normalized_ip,
+                "port": port,
+                "display": text,
+                "normalized_ip": normalized_ip,
+            }
+
+        host_candidate = text
+        if ":" in text:
+            possible_host, possible_port = text.rsplit(":", 1)
+            possible_host = possible_host.strip()
+            possible_port = possible_port.strip()
+            if possible_port.isdigit():
+                port_candidate = int(possible_port)
+                if not (1 <= port_candidate <= 65535):
+                    return None
+                try:
+                    normalized_candidate = ipaddress.ip_address(possible_host).compressed
+                except ValueError:
+                    pass
+                else:
+                    host_candidate = possible_host
+                    port = port_candidate
+                    normalized_ip = normalized_candidate
+        host_candidate = host_candidate.strip()
+        try:
+            normalized_ip = ipaddress.ip_address(host_candidate).compressed
+        except ValueError:
+            return None
+        if not (1 <= port <= 65535):
+            return None
+        return {
+            "ip": normalized_ip,
+            "port": port,
+            "display": text,
+            "normalized_ip": normalized_ip,
+        }
+
+    selected_peer: Optional[PeerInfo] = None
+    manual_selection = False
+    manual_target_info: Optional[dict[str, object]] = None
     while True:
-        choice = ui.input(get_message("prompt_peer_index", language)).strip()
+        prompt = get_message("prompt_peer_target", language, port=default_port)
+        choice = ui.input(prompt).strip()
         if not choice:
             ui.print(get_message("operation_cancelled", language))
             return
-        if not choice.isdigit():
-            ui.print(get_message("invalid_choice", language))
-            continue
-        idx = int(choice) - 1
-        if 0 <= idx < len(peers):
+        if choice.isdigit() and peers:
+            idx = int(choice) - 1
+            if 0 <= idx < len(peers):
+                selected_peer = peers[idx]
+                break
+        manual_target = parse_manual_target(choice)
+        if manual_target:
+            normalized_ip = manual_target["ip"]
+            cached_peer_id = app.cached_peer_id_for_ip(normalized_ip)
+            peer_identifier = cached_peer_id or f"manual:{normalized_ip}:{manual_target['port']}"
+            selected_peer = PeerInfo(
+                peer_id=peer_identifier,
+                name=manual_target["display"],
+                ip=normalized_ip,
+                transfer_port=manual_target["port"],
+                language=language,
+                version=__version__,
+                last_seen=time.time(),
+            )
+            manual_target_info = manual_target
+            if cached_peer_id:
+                selected_peer.peer_id = cached_peer_id
+            manual_selection = True
             break
-        ui.print(get_message("invalid_choice", language))
-    peer = peers[idx]
-    if peer.version != __version__:
+        ui.print(get_message("invalid_peer_target", language))
+
+    peer = selected_peer
+    if peer is None:
+        ui.print(get_message("operation_cancelled", language))
+        return
+    if not manual_selection and peer.version != __version__:
         ui.print(
             get_message(
                 "version_mismatch_send",
@@ -603,14 +710,16 @@ def report_progress(sent: int, total: int) -> None:
 
     def worker() -> None:
         try:
-            result, file_hash = app.send_file(
+            result, file_hash, responder_id = app.send_file(
                 peer,
                 file_path,
                 progress_cb=report_progress,
                 cancel_event=cancel_event,
             )
             result_holder["result"] = result
             result_holder["hash"] = file_hash
+            if responder_id:
+                result_holder["responder_id"] = responder_id
         except TransferCancelled as exc:
             result_holder["cancelled"] = True
             result_holder["hash"] = getattr(exc, "file_hash", None)
@@ -634,6 +743,17 @@ def worker() -> None:
     if progress_shown["value"]:
         ui.blank()
 
+    responder_id_obj = result_holder.get("responder_id")
+    if (
+        manual_selection
+        and manual_target_info
+        and isinstance(manual_target_info.get("normalized_ip"), str)
+        and isinstance(responder_id_obj, str)
+    ):
+        normalized_ip = manual_target_info["normalized_ip"]  # type: ignore[index]
+        app.remember_peer_id_for_ip(normalized_ip, responder_id_obj)
+        peer.peer_id = responder_id_obj
+
     if result_holder.get("cancelled"):
         ui.print(get_message("send_cancelled", language))
         app.log_history(

glitter/language.py

@@ -23,9 +23,11 @@
         "menu_pending": " ({count} pending)",
         "prompt_choice": "Choose an option: ",
         "no_peers": "No peers online right now.",
+        "manual_target_hint": "You can enter an IP address (IPv4/IPv6, optional :port).",
         "peer_entry": "{index}. {name} ({ip}) — last seen {seconds}s ago — v{version}",
         "peer_version_warning": "! Version mismatch detected (remote {version}, local {current}). Transfers may be unreliable; please update.",
-        "prompt_peer_index": "Select peer number: ",
+        "prompt_peer_target": "Select peer number or enter IP: ",
+        "invalid_peer_target": "Invalid selection. Enter a valid number or IP address.",
         "invalid_choice": "Invalid choice. Try again.",
         "prompt_file_path": "Enter file or directory path to send: ",
         "file_not_found": "Path not found or not a sendable file/directory.",
@@ -101,9 +103,11 @@
         "menu_pending": "（{count} 个待处理）",
         "prompt_choice": "请选择操作：",
         "no_peers": "当前没有在线客户端。",
+        "manual_target_hint": "可手动输入 IP 地址（支持 IPv4/IPv6，可选端口）。",
         "peer_entry": "{index}. {name}（{ip}）— 最近 {seconds} 秒前在线 — v{version}",
         "peer_version_warning": "! 版本不一致（对方 {version}，本地 {current}），传输可能异常，请尽快更新。",
-        "prompt_peer_index": "请选择客户端编号：",
+        "prompt_peer_target": "请输入客户端编号或 IP 地址：",
+        "invalid_peer_target": "输入无效，请输入正确的编号或 IP 地址。",
         "invalid_choice": "输入无效，请重试。",
         "prompt_file_path": "请输入要发送的文件或目录路径：",
         "file_not_found": "路径不存在或不是可发送的文件/目录。",

glitter/transfer.py

@@ -248,7 +248,7 @@ def send_file(
         file_path: Path,
         progress_cb: Optional[Callable[[int, int], None]] = None,
         cancel_event: Optional[threading.Event] = None,
-    ) -> tuple[str, str]:
+    ) -> tuple[str, str, Optional[str]]:
         if not file_path.exists():
             raise FileNotFoundError(f"path does not exist: {file_path}")
 
@@ -313,6 +313,7 @@ def send_file(
             metadata["original_size"] = original_size
         message = json.dumps(metadata, ensure_ascii=False) + "\n"
 
+        responder_id: Optional[str] = None
         try:
             with socket.create_connection((target_ip, target_port), timeout=10) as sock:
                 # Allow ample time for the receiver to review and accept the transfer
@@ -346,7 +347,7 @@ def send_file(
                     break
                 cipher: Optional[StreamCipher] = None
                 if response == "DECLINE":
-                    return "declined", file_hash
+                    return "declined", file_hash, responder_id
                 if not response.startswith("ACCEPT"):
                     raise RuntimeError(f"unexpected response: {response}")
                 payload_text = response[6:].strip()
@@ -426,7 +427,7 @@ def send_file(
                     sock.shutdown(socket.SHUT_WR)
                 except OSError:
                     pass
-                return "accepted", file_hash
+                return "accepted", file_hash, responder_id
         finally:
             if cleanup_path:
                 with contextlib.suppress(OSError):