mirror of
https://github.com/VallierDev/uu-remote-linux.git
synced 2026-11-16 08:50:40 +01:00
* Add macOS SSH companion for Finder file paste uploads * Show measured upload progress in Ghostty title and progress bar
595 lines
23 KiB
Python
Executable File
595 lines
23 KiB
Python
Executable File
#!/usr/bin/env python3
|
|
"""Paste Finder files into an SSH terminal through an existing UU TCP mapping."""
|
|
|
|
import argparse
|
|
import collections
|
|
import errno
|
|
import fcntl
|
|
import json
|
|
import os
|
|
from pathlib import Path
|
|
import pty
|
|
import queue
|
|
import re
|
|
import select
|
|
import shlex
|
|
import signal
|
|
import stat
|
|
import struct
|
|
import subprocess
|
|
import sys
|
|
import termios
|
|
import threading
|
|
import time
|
|
import tty
|
|
|
|
START, END = b"\x1b[200~", b"\x1b[201~"
|
|
ENABLE, DISABLE = b"\x1b[?2004h", b"\x1b[?2004l"
|
|
MAX_PASTE = 8 * 1024 * 1024
|
|
|
|
|
|
class PasteError(Exception):
|
|
"""Messages must not include clipboard contents, paths or subprocess output."""
|
|
|
|
|
|
def prefix_tail(data, marker):
|
|
for length in range(min(len(data), len(marker) - 1), 0, -1):
|
|
if data.endswith(marker[:length]):
|
|
return length
|
|
return 0
|
|
|
|
|
|
class InputFrames:
|
|
"""Recognize bracketed pastes across arbitrary PTY read boundaries."""
|
|
|
|
def __init__(self):
|
|
self.buffer = b""
|
|
self.pasting = False
|
|
self.overflow = False
|
|
|
|
def feed(self, data):
|
|
self.buffer += data
|
|
events = []
|
|
while self.buffer:
|
|
if self.pasting:
|
|
end = self.buffer.find(END)
|
|
if end < 0:
|
|
if len(self.buffer) > MAX_PASTE:
|
|
self.overflow = True
|
|
tail = prefix_tail(self.buffer, END)
|
|
self.buffer = self.buffer[-tail:] if tail else b""
|
|
break
|
|
payload, self.buffer = self.buffer[:end], self.buffer[end + len(END):]
|
|
events.append(("error" if self.overflow or len(payload) > MAX_PASTE else "paste", payload))
|
|
self.pasting = self.overflow = False
|
|
else:
|
|
start = self.buffer.find(START)
|
|
if start >= 0:
|
|
if start:
|
|
events.append(("data", self.buffer[:start]))
|
|
self.buffer = self.buffer[start + len(START):]
|
|
self.pasting = True
|
|
else:
|
|
tail = prefix_tail(self.buffer, START)
|
|
size = len(self.buffer) - tail
|
|
if size:
|
|
events.append(("data", self.buffer[:size]))
|
|
self.buffer = self.buffer[size:]
|
|
break
|
|
return events
|
|
|
|
def flush_key(self):
|
|
# A standalone Escape must not wait indefinitely for another key.
|
|
if not self.pasting:
|
|
result, self.buffer = self.buffer, b""
|
|
return result
|
|
return b""
|
|
|
|
|
|
class OutputModes:
|
|
"""Keep local paste framing on; retain the remote app's requested mode."""
|
|
|
|
def __init__(self):
|
|
self.buffer = b""
|
|
self.bracketed = False
|
|
|
|
def feed(self, data):
|
|
self.buffer += data
|
|
output = bytearray()
|
|
while self.buffer:
|
|
index = self.buffer.find(b"\x1b")
|
|
if index < 0:
|
|
output.extend(self.buffer)
|
|
self.buffer = b""
|
|
break
|
|
output.extend(self.buffer[:index])
|
|
self.buffer = self.buffer[index:]
|
|
if self.buffer.startswith(b"\x1bc"):
|
|
output.extend(b"\x1bc" + ENABLE)
|
|
self.bracketed = False
|
|
self.buffer = self.buffer[2:]
|
|
continue
|
|
match = re.match(rb"\x1b\[\?([0-9;]+)([hl])", self.buffer)
|
|
if match:
|
|
params = match[1].split(b";")
|
|
if b"2004" in params:
|
|
self.bracketed = match[2] == b"h"
|
|
others = [p for p in params if p != b"2004"]
|
|
if others:
|
|
output.extend(b"\x1b[?" + b";".join(others) + match[2])
|
|
output.extend(ENABLE)
|
|
else:
|
|
output.extend(match[0])
|
|
self.buffer = self.buffer[match.end():]
|
|
elif len(self.buffer) < 128 and re.fullmatch(rb"\x1b(?:\[(?:\?[0-9;]*)?)?", self.buffer):
|
|
break
|
|
else:
|
|
output.extend(self.buffer[:1])
|
|
self.buffer = self.buffer[1:]
|
|
return bytes(output)
|
|
|
|
|
|
def paste_bytes(data, bracketed):
|
|
return START + data + END if bracketed else data
|
|
|
|
|
|
def clipboard_paths(helper):
|
|
try:
|
|
result = subprocess.run([str(helper)], capture_output=True, timeout=3, check=True)
|
|
paths = json.loads(result.stdout)
|
|
if not isinstance(paths, list) or not all(isinstance(p, str) for p in paths):
|
|
raise ValueError()
|
|
return paths
|
|
except (OSError, ValueError, subprocess.SubprocessError):
|
|
raise PasteError("Cannot check copied files; paste was not sent.") from None
|
|
|
|
|
|
def copied_files(data, read_clipboard):
|
|
try:
|
|
text = data.decode("utf-8")
|
|
paths = shlex.split(text)
|
|
except (UnicodeError, ValueError):
|
|
return None
|
|
if not paths or not all(p.startswith("/") for p in paths):
|
|
return None
|
|
# Ordinary text that happens to name a local file must never upload it.
|
|
# Ghostty 1.3.1 getOpinionatedStringContents escapes Finder file paths;
|
|
# require the entire pasted path list to match actual file-URL clipboard data.
|
|
if paths != read_clipboard():
|
|
return None
|
|
if len(paths) > 256:
|
|
raise PasteError("Too many copied files (maximum 256).")
|
|
for path in paths:
|
|
if any(ord(c) < 32 or ord(c) == 127 for c in path):
|
|
raise PasteError("A copied filename contains unsupported control characters.")
|
|
try:
|
|
if not stat.S_ISREG(os.stat(path).st_mode):
|
|
raise PasteError("Copy files individually; folder pasting is not supported.")
|
|
except OSError:
|
|
raise PasteError("A copied file is no longer readable.") from None
|
|
if len({Path(p).name for p in paths}) != len(paths):
|
|
raise PasteError("Copied files must have distinct filenames; paste them separately.")
|
|
return paths
|
|
|
|
|
|
class SCPMeter:
|
|
"""Reduce OpenSSH's private progress output to numeric batch counters."""
|
|
|
|
# OpenSSH progressmeter.c writes: filename percent size rate time [ETA].
|
|
# Anchor at the numeric suffix; filenames and errors are never displayed.
|
|
record = re.compile(rb" (\d{1,3})%\s+(\d{1,20}(?:[KMGT]B)?)\s+"
|
|
rb"(\d{1,20}(?:\.\d{1,10})?[KMGT]B)/s\s+"
|
|
rb"(?:\d+:\d\d(?::\d\d)?(?: ETA)?|--:-- ETA|- stalled -)\s*$")
|
|
|
|
def __init__(self, sizes, report):
|
|
self.sizes, self.report = sizes, report
|
|
self.buffer, self.index, self.finished = b"", 0, 0
|
|
self.current, self.percent = 0, 0
|
|
|
|
@staticmethod
|
|
def amount(token):
|
|
match = re.fullmatch(rb"(\d+(?:\.\d+)?)([KMGT])?B?", token)
|
|
return int(float(match[1]) * 1024 ** (b" KMGT".index(match[2]) if match[2] else 0))
|
|
|
|
def parse(self, line):
|
|
match = self.record.search(line)
|
|
if not match or self.index >= len(self.sizes):
|
|
return
|
|
percent = int(match[1])
|
|
if percent > 100:
|
|
return
|
|
self.percent = max(self.percent, percent)
|
|
size = self.sizes[self.index]
|
|
self.current = max(self.current, min(size, self.amount(match[2])))
|
|
if percent == 100:
|
|
self.current = size
|
|
self.report("uploading", self.finished + self.current, sum(self.sizes), self.amount(match[3]))
|
|
|
|
def feed(self, data):
|
|
for piece in re.split(rb"([\r\n])", data):
|
|
if piece in (b"\r", b"\n"):
|
|
self.parse(self.buffer)
|
|
self.buffer = b""
|
|
if piece == b"\n" and self.percent == 100:
|
|
self.finished += self.sizes[self.index]
|
|
self.index += 1
|
|
self.current = self.percent = 0
|
|
else:
|
|
# Keep only enough for a numeric suffix, not unlimited errors.
|
|
self.buffer = (self.buffer + piece)[-512:]
|
|
self.parse(self.buffer)
|
|
|
|
|
|
def run_metered(args, cancel, timeout, meter):
|
|
master, slave = pty.openpty()
|
|
fcntl.ioctl(slave, termios.TIOCSWINSZ, struct.pack("HHHH", 24, 120, 0, 0))
|
|
|
|
try:
|
|
# The upload runs on a worker thread, so avoid Python preexec_fn after
|
|
# fork. Acquire the private controlling TTY in a fresh interpreter.
|
|
launch = ("import fcntl,os,sys,termios;fcntl.ioctl(1,termios.TIOCSCTTY,0);"
|
|
"os.execv(sys.argv[1],sys.argv[1:])")
|
|
with subprocess.Popen([sys.executable, "-c", launch, *args],
|
|
stdin=subprocess.DEVNULL, stdout=slave, stderr=slave,
|
|
start_new_session=True) as process:
|
|
os.close(slave)
|
|
slave = None
|
|
deadline = time.monotonic() + timeout
|
|
try:
|
|
while True:
|
|
if cancel.is_set() or time.monotonic() > deadline:
|
|
raise PasteError("Upload cancelled or timed out; paste was not sent.")
|
|
if select.select([master], [], [], 0.1)[0]:
|
|
try:
|
|
data = os.read(master, 65536)
|
|
except OSError as error:
|
|
if error.errno != errno.EIO:
|
|
raise
|
|
data = b""
|
|
if not data:
|
|
break
|
|
meter.feed(data)
|
|
elif process.poll() is not None:
|
|
break
|
|
try:
|
|
status = process.wait(timeout=max(0.1, deadline - time.monotonic()))
|
|
except subprocess.TimeoutExpired:
|
|
raise PasteError("Upload timed out; paste was not sent.") from None
|
|
if status:
|
|
raise PasteError("Upload failed; paste was not sent.")
|
|
finally:
|
|
if process.poll() is None:
|
|
os.killpg(process.pid, signal.SIGKILL)
|
|
process.wait()
|
|
finally:
|
|
os.close(master)
|
|
if slave is not None:
|
|
os.close(slave)
|
|
return b""
|
|
|
|
|
|
def run_private(args, cancel, timeout, meter=None):
|
|
# Neither SSH errors nor SCP output may disclose paths, clipboard/file data,
|
|
# or credentials. Authentication never reads from the interactive terminal.
|
|
if meter is not None:
|
|
return run_metered(args, cancel, timeout, meter)
|
|
with subprocess.Popen(args, stdin=subprocess.DEVNULL, stdout=subprocess.PIPE,
|
|
stderr=subprocess.DEVNULL, start_new_session=True) as process:
|
|
deadline = time.monotonic() + timeout
|
|
while True:
|
|
if cancel.is_set() or time.monotonic() > deadline:
|
|
os.killpg(process.pid, signal.SIGKILL)
|
|
process.communicate()
|
|
raise PasteError("Upload cancelled." if cancel.is_set() else "Upload timed out; paste was not sent.")
|
|
try:
|
|
stdout, _ = process.communicate(timeout=0.1)
|
|
if process.returncode:
|
|
raise PasteError("Upload failed; check the UU mapping and SSH access. Paste was not sent.")
|
|
return stdout
|
|
except subprocess.TimeoutExpired:
|
|
pass
|
|
|
|
|
|
class Uploader:
|
|
def __init__(self, config, host):
|
|
common = ["-F", str(config)] if config else []
|
|
common += ["-o", "BatchMode=yes", "-o", "ConnectTimeout=15"]
|
|
self.ssh = ["/usr/bin/ssh", *common, host]
|
|
self.scp = ["/usr/bin/scp", "-q", *common]
|
|
self.host = host
|
|
|
|
def upload(self, paths, cancel, progress=None):
|
|
sizes = [os.stat(path).st_size for path in paths] if progress else []
|
|
if progress:
|
|
progress("connecting", 0, sum(sizes), 0)
|
|
script = ('umask 077; d="$HOME/.local/share/uuremote/uploads"; '
|
|
'mkdir -p "$d" && mktemp -d "$d/paste.XXXXXXXX"')
|
|
try:
|
|
directory = run_private([*self.ssh, script], cancel, 30).decode("utf-8").strip()
|
|
except UnicodeError:
|
|
raise PasteError("Invalid upload destination; paste was not sent.") from None
|
|
if (not directory.startswith("/") or len(directory) > 4096 or
|
|
any(ord(c) < 32 or ord(c) == 127 for c in directory) or
|
|
not re.fullmatch(r"paste\.[A-Za-z0-9]+", directory.rsplit("/", 1)[-1])):
|
|
raise PasteError("Invalid upload destination; paste was not sent.")
|
|
try:
|
|
# Use modern SCP's SFTP mode, never legacy SCP (-O). Unique batch
|
|
# directories prevent overwrites; all local paths are absolute.
|
|
if progress:
|
|
progress("uploading", 0, sum(sizes), 0)
|
|
scp = self.scp[:1] + self.scp[2:] # Remove only our own -q.
|
|
run_private([*scp, *paths, f"{self.host}:{directory}/"], cancel, 300,
|
|
SCPMeter(sizes, progress))
|
|
progress("finishing", sum(sizes), sum(sizes), 0)
|
|
else:
|
|
run_private([*self.scp, *paths, f"{self.host}:{directory}/"], cancel, 300)
|
|
except (PasteError, OSError):
|
|
# Clean only this batch, with quoted remote shell syntax. Cancellation
|
|
# of one upload must not stop another SSH/UU session.
|
|
try:
|
|
run_private([*self.ssh, "rm -rf -- " + shlex.quote(directory)], threading.Event(), 10)
|
|
except (PasteError, OSError):
|
|
pass
|
|
raise
|
|
return " ".join(shlex.quote(directory + "/" + Path(p).name) for p in paths).encode("utf-8")
|
|
|
|
|
|
def write_all(fd, data):
|
|
view = memoryview(data)
|
|
while view:
|
|
view = view[os.write(fd, view):]
|
|
|
|
|
|
def display_size(size):
|
|
for unit in ("B", "KiB", "MiB", "GiB", "TiB"):
|
|
if size < 1024 or unit == "TiB":
|
|
return f"{size:.0f} {unit}" if unit == "B" else f"{size:.1f} {unit}"
|
|
size /= 1024
|
|
|
|
|
|
class UploadDisplay:
|
|
"""Session-local title and OSC 9;4 progress; terminal cells stay untouched."""
|
|
|
|
# https://ghostty.org/docs/vt/osc/conemu: states 0=clear, 1=percent, 3=busy.
|
|
|
|
def __init__(self, emit):
|
|
self.emit, self.active = emit, False
|
|
self.title, self.pending = b"UU SSH", b""
|
|
self.state = ("connecting", 0, 0, 0)
|
|
self.started = self.rendered = 0
|
|
|
|
def observe(self, data):
|
|
self.pending = (self.pending + data)[-8192:]
|
|
for match in re.finditer(rb"\x1b\][02];([^\x07\x1b]*)(?:\x07|\x1b\\)", self.pending):
|
|
self.title = match[1]
|
|
# Retain only an incomplete OSC title across output reads.
|
|
index = self.pending.rfind(b"\x1b]")
|
|
if index < 0:
|
|
self.pending = b"\x1b" if self.pending.endswith(b"\x1b") else b""
|
|
else:
|
|
tail = self.pending[index:]
|
|
self.pending = tail if b"\x07" not in tail and b"\x1b\\" not in tail else b""
|
|
|
|
def start(self, total):
|
|
self.active = True
|
|
self.started = time.monotonic()
|
|
self.state = ("connecting", 0, total, 0)
|
|
self.render(force=True)
|
|
|
|
def update(self, stage, done, total, speed):
|
|
self.state = stage, done, total, speed
|
|
|
|
def render(self, force=False):
|
|
now = time.monotonic()
|
|
if not self.active or (not force and now - self.rendered < 0.2):
|
|
return
|
|
self.rendered = now
|
|
stage, done, total, speed = self.state
|
|
elapsed = int(now - self.started)
|
|
if stage in ("connecting", "cancelling"):
|
|
label = "Connecting" if stage == "connecting" else "Cancelling"
|
|
text = f"UU upload: {label} | {display_size(total)} | {elapsed}s"
|
|
indicator = b"\x1b]9;4;3\x1b\\"
|
|
else:
|
|
percent = min(100, int(done * 100 / total)) if total else 100
|
|
label = "Finishing" if stage == "finishing" else "Uploading"
|
|
text = (f"UU upload: {label} {percent}% | {display_size(done)}/{display_size(total)}"
|
|
f" | {display_size(speed)}/s | {elapsed}s")
|
|
indicator = f"\x1b]9;4;1;{percent}\x1b\\".encode()
|
|
self.emit(b"\x1b]2;" + text.encode() + b"\x1b\\" + indicator)
|
|
|
|
def finish(self):
|
|
if self.active:
|
|
self.active = False
|
|
self.emit(b"\x1b]9;4;0\x1b\\\x1b]2;" + self.title + b"\x1b\\")
|
|
|
|
|
|
def relay(command, read_clipboard, uploader):
|
|
original = termios.tcgetattr(0)
|
|
master, slave = pty.openpty()
|
|
|
|
def resize(*_):
|
|
try:
|
|
size = fcntl.ioctl(0, termios.TIOCGWINSZ, bytes(8))
|
|
fcntl.ioctl(master, termios.TIOCSWINSZ, size)
|
|
except OSError:
|
|
pass
|
|
|
|
resize()
|
|
|
|
def child_tty():
|
|
os.setsid()
|
|
fcntl.ioctl(0, termios.TIOCSCTTY, 0)
|
|
|
|
child = subprocess.Popen(command, stdin=slave, stdout=slave, stderr=slave, preexec_fn=child_tty)
|
|
os.close(slave)
|
|
previous_resize = signal.signal(signal.SIGWINCH, resize)
|
|
|
|
def shutdown(signum, _frame):
|
|
raise SystemExit(128 + signum)
|
|
|
|
previous_signals = {sig: signal.signal(sig, shutdown)
|
|
for sig in (signal.SIGHUP, signal.SIGTERM, signal.SIGINT)}
|
|
frames, modes = InputFrames(), OutputModes()
|
|
events, completed = collections.deque(), queue.Queue()
|
|
updates = queue.Queue()
|
|
display = UploadDisplay(lambda data: write_all(1, data))
|
|
cancel, uploading, interrupted = threading.Event(), False, False
|
|
worker = None
|
|
last_input = time.monotonic()
|
|
|
|
def upload_worker(paths):
|
|
try:
|
|
completed.put((uploader.upload(paths, cancel, lambda *args: updates.put(args)), None))
|
|
except (OSError, PasteError):
|
|
completed.put((None, "Upload failed or cancelled; paste was not sent."))
|
|
|
|
def notice(message):
|
|
write_all(2, ("\r\n[UU paste] " + message + "\r\n").encode())
|
|
|
|
def interrupt_upload():
|
|
nonlocal interrupted, frames
|
|
if not uploading:
|
|
return
|
|
pending = list(events)
|
|
positions = [(i, payload.rfind(b"\x03")) for i, (kind, payload) in enumerate(pending)
|
|
if kind == "data" and b"\x03" in payload]
|
|
if positions:
|
|
index, offset = positions[-1]
|
|
cancel.set()
|
|
interrupted = True
|
|
_, done, total, _ = display.state
|
|
display.update("cancelling", done, total, 0)
|
|
display.render(force=True)
|
|
frames = InputFrames()
|
|
events.clear()
|
|
events.extend(frames.feed(pending[index][1][offset + 1:]))
|
|
events.extend(pending[index + 1:])
|
|
write_all(master, b"\x03")
|
|
|
|
try:
|
|
tty.setraw(0)
|
|
write_all(1, ENABLE)
|
|
while True:
|
|
interrupt_upload()
|
|
while not updates.empty():
|
|
update = updates.get_nowait()
|
|
if not interrupted:
|
|
display.update(*update)
|
|
if uploading:
|
|
display.render()
|
|
try:
|
|
data, error = completed.get_nowait()
|
|
except queue.Empty:
|
|
pass
|
|
else:
|
|
uploading = False
|
|
display.finish()
|
|
if error:
|
|
notice(error)
|
|
elif not interrupted:
|
|
write_all(master, paste_bytes(data, modes.bracketed))
|
|
while events and not uploading:
|
|
kind, data = events.popleft()
|
|
if kind == "error":
|
|
notice("Paste exceeds 8 MiB; paste was not sent.")
|
|
continue
|
|
if kind == "data":
|
|
write_all(master, data)
|
|
continue
|
|
try:
|
|
files = copied_files(data, read_clipboard)
|
|
except PasteError as error:
|
|
notice(str(error))
|
|
continue
|
|
if files is None:
|
|
write_all(master, paste_bytes(data, modes.bracketed))
|
|
else:
|
|
try:
|
|
total = sum(os.stat(path).st_size for path in files)
|
|
except OSError:
|
|
notice("A copied file is no longer readable; paste was not sent.")
|
|
continue
|
|
cancel.clear()
|
|
uploading, interrupted = True, False
|
|
display.start(total)
|
|
worker = threading.Thread(target=upload_worker, args=(files,), daemon=True)
|
|
worker.start()
|
|
interrupt_upload()
|
|
readable, _, _ = select.select([0, master], [], [], 0.025)
|
|
if master in readable:
|
|
try:
|
|
data = os.read(master, 65536)
|
|
except OSError as error:
|
|
if error.errno != errno.EIO:
|
|
raise
|
|
data = b""
|
|
if not data:
|
|
break
|
|
display.observe(data)
|
|
write_all(1, modes.feed(data))
|
|
if 0 in readable:
|
|
data = os.read(0, 65536)
|
|
if not data:
|
|
break
|
|
last_input = time.monotonic()
|
|
events.extend(frames.feed(data))
|
|
if sum(len(payload) for _, payload in events) > MAX_PASTE:
|
|
events.clear()
|
|
notice("Input queue is full; queued input was discarded.")
|
|
elif time.monotonic() - last_input > 0.025:
|
|
data = frames.flush_key()
|
|
if data:
|
|
events.append(("data", data))
|
|
if modes.buffer:
|
|
write_all(1, modes.buffer)
|
|
finally:
|
|
cancel.set()
|
|
signal.signal(signal.SIGWINCH, previous_resize)
|
|
for sig, previous in previous_signals.items():
|
|
signal.signal(sig, previous)
|
|
termios.tcsetattr(0, termios.TCSADRAIN, original)
|
|
display.finish()
|
|
write_all(1, DISABLE)
|
|
os.close(master)
|
|
if child.poll() is None:
|
|
try:
|
|
child.wait(timeout=2)
|
|
except subprocess.TimeoutExpired:
|
|
os.killpg(child.pid, signal.SIGTERM)
|
|
try:
|
|
child.wait(timeout=2)
|
|
except subprocess.TimeoutExpired:
|
|
os.killpg(child.pid, signal.SIGKILL)
|
|
status = child.wait()
|
|
if worker is not None:
|
|
worker.join(timeout=12)
|
|
return status if status >= 0 else 128 - status
|
|
|
|
|
|
def main():
|
|
parser = argparse.ArgumentParser(description=__doc__)
|
|
parser.add_argument("-F", "--ssh-config", type=Path)
|
|
parser.add_argument("host", help="SSH alias for an existing UU loopback port mapping")
|
|
parser.add_argument("command", nargs=argparse.REMAINDER)
|
|
args = parser.parse_args()
|
|
if not re.fullmatch(r"[A-Za-z0-9][A-Za-z0-9_.@-]*", args.host):
|
|
parser.error("use an SSH host alias, without options or a port")
|
|
common = ["-F", str(args.ssh_config)] if args.ssh_config else []
|
|
command = ["/usr/bin/ssh", *common]
|
|
if not (os.isatty(0) and os.isatty(1)):
|
|
os.execv(command[0], [*command, args.host, *args.command])
|
|
helper = Path(__file__).resolve().with_name("clipboard-files")
|
|
if not helper.is_file():
|
|
parser.error("run contrib/macos-ssh/install.sh on your Mac first")
|
|
return relay([*command, "-tt", args.host, *args.command],
|
|
lambda: clipboard_paths(helper), Uploader(args.ssh_config, args.host))
|
|
|
|
|
|
if __name__ == "__main__":
|
|
try:
|
|
sys.exit(main())
|
|
except (OSError, PasteError):
|
|
print("UU SSH companion failed; check the UU mapping and SSH configuration.", file=sys.stderr)
|
|
sys.exit(1)
|