diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 444a62e..cc082f2 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -6,6 +6,16 @@ on: pull_request: jobs: + test-macos-ssh-paste: + runs-on: macos-latest + steps: + - uses: actions/checkout@v4 + - run: python3 -m unittest discover -s contrib/macos-ssh -p 'test_*.py' -v + - name: Test file-URL clipboard reader on a private pasteboard + run: | + swiftc -O contrib/macos-ssh/clipboard-files.swift -o "$RUNNER_TEMP/clipboard-files" + "$RUNNER_TEMP/clipboard-files" --self-test + test: runs-on: ubuntu-22.04 steps: diff --git a/README.en.md b/README.en.md index 0b36475..e07ccdf 100644 --- a/README.en.md +++ b/README.en.md @@ -236,6 +236,13 @@ service and run `loginctl enable-linger $USER`, so the systemd user manager (wit starts at boot without a login. The viewer's remote desktop keeps showing "connecting" in this mode; that is expected. Log in once with `uuremote-server login --no-gui` (QR in the terminal). +**Paste files from a Mac terminal**: when using Ghostty over UU's SSH port mapping, +the optional [Mac SSH paste companion](contrib/macos-ssh/README.md) uploads files +copied in Finder before inserting their remote paths. Text and mouse reports pass +through. Ghostty's title and progress bar show upload progress, transferred size, +speed and elapsed time. It does not change the official UU terminal; folders, drag-and-drop and +raw screenshot clipboard data are not supported. + **Virtual desktop**: for a full remote desktop, run a desktop session (Xfce recommended) on an Xvfb screen: ```sh diff --git a/README.md b/README.md index c596fd7..7a3c924 100644 --- a/README.md +++ b/README.md @@ -209,6 +209,12 @@ install -Dm644 contrib/desktop/uu-remote-linux.desktop ~/.local/share/applicatio 再执行 `loginctl enable-linger $USER`,这样开机后不用登录,systemd 用户服务(以及 `XDG_RUNTIME_DIR`、用户 D-Bus)也会自动启动。 无头模式下控制端点「远程桌面」会一直显示正在连接,这是正常的。首次登录用 `uuremote-server login --no-gui` 在终端里扫码。 +**Mac 终端粘贴文件**:使用 Ghostty 通过 UU 端口映射连接 SSH 时,可安装 +[Mac SSH 粘贴助手](contrib/macos-ssh/README.md)。在 Finder 复制文件后按 Command-V, +助手先通过同一个 SSH 别名上传文件,再插入服务器路径;普通文本和鼠标报告正常透传。 +Ghostty 标题栏和进度条显示上传进度、已传大小、速度和耗时。 +这是可选的 Mac 端工具,不会改变官方 UU 内置终端;暂不支持文件夹、拖放或原始截图剪贴板。 + **虚拟桌面**:需要完整的远程桌面时,用 Xvfb 创建一块虚拟屏幕,再在上面跑一个桌面环境(推荐 Xfce): ```sh diff --git a/contrib/macos-ssh/.gitignore b/contrib/macos-ssh/.gitignore new file mode 100644 index 0000000..c18dd8d --- /dev/null +++ b/contrib/macos-ssh/.gitignore @@ -0,0 +1 @@ +__pycache__/ diff --git a/contrib/macos-ssh/README.md b/contrib/macos-ssh/README.md new file mode 100644 index 0000000..460749f --- /dev/null +++ b/contrib/macos-ssh/README.md @@ -0,0 +1,103 @@ +# Paste copied files into a UU-mapped SSH terminal on macOS + +This optional Mac companion uploads files copied in Finder when you paste them +into Ghostty, then inserts shell-quoted **remote** paths into the terminal. +For example, copy an image in Finder, connect with `uu-ssh-paste`, and press +Command-V at a remote shell prompt or in a terminal application's text field. +The file is available on the server before its path is inserted. No Enter is sent. + +The connection is Ghostty → OpenSSH → your existing UU TCP mapping → the Linux +host's SSH server. Both terminal traffic and uploads use the same SSH alias. +The companion does not create a mapping or fall back to a public network route. +The official Mac UU application's built-in terminal is unaffected. + +## Install and connect + +On the controlling Mac, install Python 3 and Apple's command-line developer +tools (for `swiftc`), then run from this repository: + +```sh +sh contrib/macos-ssh/install.sh +``` + +Enable port mapping on your Linux UU host (`UU_PORT_MAPPING=1`); in the official +Mac UU app, map a **local loopback** port to `127.0.0.1:22` on that host. Keep +the mapping connected. Configure an SSH alias for that local port, using your +existing key and the server's verified host key. For example: + +```sshconfig +Host uu-server + HostName 127.0.0.1 + Port 22243 + User your-linux-user + IdentityFile ~/.ssh/id_ed25519 + IdentitiesOnly yes + HostKeyAlias your-existing-server-host-key-name + StrictHostKeyChecking yes + ProxyCommand none + ProxyJump none +``` + +In Ghostty, connect using that alias: + +```sh +uu-ssh-paste uu-server +# Or use a separate SSH config: +uu-ssh-paste -F ~/.config/your-uu-ssh.conf uu-server +``` + +Copy one or several files in Finder with Command-C, switch to the connected +terminal, and press Command-V. Each paste creates a unique mode-0700 directory +under `~/.local/share/uuremote/uploads/` on the server. Files remain there until +you remove them. Filenames with spaces, Unicode and shell metacharacters are +supported. Existing files are never overwritten by another paste batch. + +Text paste, SSH exit statuses, terminal resizing and mouse reports pass through. +The remote application still controls whether it receives bracketed paste and +mouse movement. Ctrl-C during a transfer cancels that paste. Input typed while +the upload is running is queued, so Enter cannot overtake the uploaded path. + +Ghostty's title bar shows the connection phase, upload percentage, transferred +size, transfer speed and elapsed time. Its progress indicator tracks the upload +too. Progress is derived from OpenSSH's transfer meter, aggregated across copied +files; it is not a simulated timer. The original terminal title is restored when +the upload finishes, fails or is cancelled, and no terminal cells are overwritten. +Filename and error output from SCP stays private; only numeric progress is shown. + +## Scope and failure behavior + +- Only file-URL clipboard entries copied in Finder are uploaded, and only when + they match the complete pasted path list. Pasting a textual local path or a + command does not upload anything. The clipboard is never modified or polled + in the background; file URLs are read only during a potential file paste. +- Folder paste, drag-and-drop and raw screenshot/image clipboard data are not + supported. Save an image as a file and copy that file in Finder first. +- The SSH server must support SFTP. Upload authentication is noninteractive + (`BatchMode=yes`); the alias must already work with a key or SSH agent. +- Missing files, duplicate basenames in a batch, control characters in filenames, + failed uploads and clipboard-reader failures do not insert a misleading path. + Failed transfer directories are removed on a best-effort basis. No file names, + clipboard contents, file contents, terminal input or SSH error text are logged. +- A paste is limited to 256 files and 8 MiB of pasted path/text data. Transfers + time out after five minutes. File sizes themselves are not limited to 8 MiB. +- The companion keeps local bracketed-paste framing enabled while the session + runs and removes framing for remote applications that have not requested it. + No global Ghostty configuration, remote desktop or Wine component is needed. + +## Tests + +```sh +python3 -m unittest discover -s contrib/macos-ssh -p 'test_*.py' -v +swiftc -O contrib/macos-ssh/clipboard-files.swift -o /tmp/clipboard-files +/tmp/clipboard-files --self-test +# Optional real SSH/SFTP acceptance test over an already connected UU mapping: +UU_PASTE_TEST_HOST=uu-server UU_PASTE_TEST_CONFIG="$HOME/.config/your-uu-ssh.conf" \ + python3 -m unittest discover -s contrib/macos-ssh -p 'test_*.py' -v +``` + +The Swift test uses a private pasteboard and never touches the user's clipboard. +Python tests exercise fragmented paste framing, shell quoting, plain text, +mouse reports, failed uploads, queued Enter, PTY restoration and exit status. +The optional live tests transfer synthetic binary files and verify hashes, +including a throttled upload that must report intermediate byte progress. +Physical Command-C/Command-V behavior in Finder/Ghostty remains a manual check. diff --git a/contrib/macos-ssh/clipboard-files.swift b/contrib/macos-ssh/clipboard-files.swift new file mode 100644 index 0000000..c02972f --- /dev/null +++ b/contrib/macos-ssh/clipboard-files.swift @@ -0,0 +1,29 @@ +import AppKit +import Foundation + +// Only file URLs are read. Text, images and the general pasteboard are never +// written, and the result is consumed privately by the SSH companion. +func filePaths(_ board: NSPasteboard) -> [String] { + let options: [NSPasteboard.ReadingOptionKey: Any] = [.urlReadingFileURLsOnly: true] + return (board.readObjects(forClasses: [NSURL.self], options: options) as? [URL] ?? []) + .filter { $0.isFileURL }.map { $0.path } +} + +if CommandLine.arguments.dropFirst().first == "--self-test" { + // An isolated pasteboard: tests never read or overwrite the user's clipboard. + let board = NSPasteboard.withUniqueName() + defer { board.releaseGlobally() } + let paths = ["/tmp/space and 中文.png", "/tmp/quote'$(literal).txt"] + board.writeObjects(paths.map { NSURL(fileURLWithPath: $0) }) + precondition(filePaths(board) == paths) + board.clearContents() + board.setString("/tmp/text-is-not-a-file", forType: .string) + precondition(filePaths(board).isEmpty) + board.clearContents() + board.writeObjects([NSURL(string: "https://example.invalid/file")!]) + precondition(filePaths(board).isEmpty) + print("Private pasteboard tests passed") +} else { + let data = try JSONSerialization.data(withJSONObject: filePaths(.general)) + FileHandle.standardOutput.write(data) +} diff --git a/contrib/macos-ssh/install.sh b/contrib/macos-ssh/install.sh new file mode 100755 index 0000000..1fd4e62 --- /dev/null +++ b/contrib/macos-ssh/install.sh @@ -0,0 +1,27 @@ +#!/bin/sh +set -eu +if [ "$(uname -s)" != Darwin ]; then + echo 'Install this companion on the controlling Mac.' >&2 + exit 1 +fi +command -v python3 >/dev/null +source_dir=$(CDPATH= cd -- "$(dirname -- "$0")" && pwd) +data_dir="$HOME/.local/share/uuremote/macos-ssh" +bin_dir="$HOME/.local/bin" +mkdir -p "$data_dir" "$bin_dir" +scratch=$(mktemp -d) +trap 'rm -rf "$scratch"' EXIT HUP INT TERM +swiftc -O "$source_dir/clipboard-files.swift" -o "$scratch/clipboard-files" +"$scratch/clipboard-files" --self-test +install -m 755 "$scratch/clipboard-files" "$data_dir/clipboard-files" +install -m 755 "$source_dir/uu-ssh-paste" "$data_dir/uu-ssh-paste" +if [ -e "$bin_dir/uu-ssh-paste" ] && [ ! -L "$bin_dir/uu-ssh-paste" ]; then + echo 'An existing uu-ssh-paste file was preserved; inspect it before replacing it.' >&2 + exit 1 +fi +if [ -L "$bin_dir/uu-ssh-paste" ] && [ "$(readlink "$bin_dir/uu-ssh-paste")" != "$data_dir/uu-ssh-paste" ]; then + echo 'An unrelated uu-ssh-paste symlink was preserved; inspect it before replacing it.' >&2 + exit 1 +fi +ln -sfn "$data_dir/uu-ssh-paste" "$bin_dir/uu-ssh-paste" +echo 'Installed uu-ssh-paste. Connect using your existing UU SSH alias.' diff --git a/contrib/macos-ssh/test_paste.py b/contrib/macos-ssh/test_paste.py new file mode 100644 index 0000000..5a163ed --- /dev/null +++ b/contrib/macos-ssh/test_paste.py @@ -0,0 +1,472 @@ +"""Synthetic fixtures only; never inspect or change the general pasteboard.""" + +import base64 +import errno +import hashlib +import importlib.machinery +import importlib.util +import json +import os +from pathlib import Path +import pty +import select +import shlex +import signal +import struct +import subprocess +import sys +import tempfile +import termios +import threading +import time +import unittest +from unittest import mock + + +SCRIPT = Path(__file__).with_name("uu-ssh-paste") +loader = importlib.machinery.SourceFileLoader("uu_paste", str(SCRIPT)) +spec = importlib.util.spec_from_loader(loader.name, loader) +paste = importlib.util.module_from_spec(spec) +loader.exec_module(paste) + + +class FramingTests(unittest.TestCase): + def test_paste_at_every_fragment_boundary_and_multiple_pastes(self): + wire = b"key" + paste.START + b"hello\nworld" + paste.END + b"\r" + expected = [("data", b"key"), ("paste", b"hello\nworld"), ("data", b"\r")] + for split in range(len(wire) + 1): + frames = paste.InputFrames() + events = frames.feed(wire[:split]) + frames.feed(wire[split:]) + merged = [] + for kind, data in events: + if kind == "data" and merged and merged[-1][0] == "data": + merged[-1] = (kind, merged[-1][1] + data) + else: + merged.append((kind, data)) + self.assertEqual(merged, expected) + frames = paste.InputFrames() + self.assertEqual(frames.feed(paste.START + b"a" + paste.END + paste.START + b"b" + paste.END), + [("paste", b"a"), ("paste", b"b")]) + + def test_mouse_and_arrow_bytes_and_standalone_escape(self): + raw = b"\x1b[<2;12;4M\x1b[<2;12;4m\x1b[<35;13;5M\x1b[A\x1b" + frames = paste.InputFrames() + output = b"".join(data for kind, data in frames.feed(raw) if kind == "data") + self.assertEqual(output + frames.flush_key(), raw) + + def test_oversized_paste_is_discarded_and_parser_recovers(self): + frames = paste.InputFrames() + with mock.patch.object(paste, "MAX_PASTE", 16): + self.assertEqual(frames.feed(paste.START + b"x" * 40), []) + self.assertEqual(frames.feed(paste.END + b"next")[-1], ("data", b"next")) + self.assertFalse(frames.pasting) + self.assertLess(len(frames.buffer), 16) + + def test_remote_modes_track_split_sequences_without_disabling_local_framing(self): + for split in range(len(paste.DISABLE) + 1): + modes = paste.OutputModes() + modes.bracketed = True + result = modes.feed(paste.DISABLE[:split]) + modes.feed(paste.DISABLE[split:]) + self.assertEqual(result, paste.ENABLE) + self.assertFalse(modes.bracketed) + modes = paste.OutputModes() + self.assertEqual(modes.feed(b"\x1b[?1;2004h"), b"\x1b[?1h" + paste.ENABLE) + self.assertTrue(modes.bracketed) + self.assertEqual(modes.feed(b"\x1b[?2004;25l"), b"\x1b[?25l" + paste.ENABLE) + self.assertFalse(modes.bracketed) + self.assertEqual(modes.feed(b"\x1bc"), b"\x1bc" + paste.ENABLE) + raw = b"\x1b[31mhello\x1b[0m\x1b]0;title\x07" + self.assertEqual(modes.feed(raw), raw) + + +class FileTests(unittest.TestCase): + def setUp(self): + self.temp = tempfile.TemporaryDirectory() + self.addCleanup(self.temp.cleanup) + self.root = Path(self.temp.name) + self.files = [self.root / "space 中文.png", self.root / "quote'$(literal);.txt"] + for path in self.files: + path.write_bytes(os.urandom(1025)) + self.paths = [str(p) for p in self.files] + # Ghostty uses backslash escaping rather than POSIX single quotes. + escape = "\\ ()[]{}<>\"'`!#$&;|*?\t" + self.payload = " ".join("".join("\\" + c if c in escape else c for c in p) + for p in self.paths).encode() + + def test_finder_files_match_ghostty_escaping(self): + self.assertEqual(paste.copied_files(self.payload, lambda: self.paths), self.paths) + + def test_plain_text_and_pasted_commands_do_not_upload(self): + clipboard = mock.Mock(return_value=[]) + for value in (b"hello\nworld", b"cat /tmp/file", b"\xff", b"'unterminated"): + self.assertIsNone(paste.copied_files(value, clipboard)) + clipboard.assert_not_called() + self.assertIsNone(paste.copied_files(self.payload, lambda: [])) + self.assertIsNone(paste.copied_files(self.payload, lambda: self.paths[::-1])) + + def test_missing_files_folders_duplicate_names_and_control_characters_rejected(self): + cases = [[str(self.root)], [str(self.root / "missing")]] + newline = self.root / "bad\nname" + newline.write_text("synthetic") + cases.append([str(newline)]) + folder = self.root / "another" + folder.mkdir() + duplicate = folder / self.files[0].name + duplicate.write_text("synthetic") + cases.append([self.paths[0], str(duplicate)]) + for paths in cases: + with self.assertRaises(paste.PasteError): + paste.copied_files(shlex.join(paths).encode(), lambda: paths) + + def test_upload_paths_are_quoted_and_failed_batch_is_cleaned(self): + uploader = paste.Uploader(self.root / "config with spaces", "uu-test") + directory = b"/home/test user/.local/share/uuremote/uploads/paste.ABCD1234\n" + with mock.patch.object(paste, "run_private", side_effect=[directory, b""]) as run: + result = uploader.upload(self.paths, threading.Event()) + self.assertEqual(shlex.split(result.decode()), + [directory.decode().strip() + "/" + p.name for p in self.files]) + self.assertEqual(run.call_args_list[1].args[0][-3:-1], self.paths) + self.assertNotIn("-O", run.call_args_list[1].args[0]) + self.assertIn("BatchMode=yes", run.call_args_list[1].args[0]) + with mock.patch.object(paste, "run_private", side_effect=[directory, paste.PasteError("failed"), b""]) as run: + with self.assertRaises(paste.PasteError): + uploader.upload(self.paths, threading.Event()) + cleanup = run.call_args_list[2].args[0][-1] + self.assertEqual(shlex.split(cleanup), ["rm", "-rf", "--", directory.decode().strip()]) + + def test_bad_destination_and_bad_clipboard_fail_without_content_in_error(self): + uploader = paste.Uploader(None, "uu-test") + for output in (b"relative", b"/tmp/invalid", b"/tmp/paste.abc\nextra", b"\xff"): + with mock.patch.object(paste, "run_private", return_value=output): + with self.assertRaises(paste.PasteError): + uploader.upload(self.paths, threading.Event()) + with mock.patch.object(paste.subprocess, "run", return_value=subprocess.CompletedProcess([], 0, b"{}")): + with self.assertRaises(paste.PasteError): + paste.clipboard_paths("helper") + + def test_cancellation_stops_transfer(self): + cancel = threading.Event() + cancel.set() + with self.assertRaisesRegex(paste.PasteError, "cancelled"): + paste.run_private([sys.executable, "-c", "import time;time.sleep(30)"], cancel, 3) + + +class ProgressTests(unittest.TestCase): + def test_numeric_meter_handles_fragments_multiple_files_and_rounding(self): + for fragment in (1, 7, 9999): + reports = [] + meter = paste.SCPMeter([1048576, 1025], lambda *args: reports.append(args)) + wire = (b"\rprivate-file 0% 0 0.0KB/s --:-- ETA" + b"\rprivate-file 50% 512KB 128.0KB/s 00:04 ETA" + b"\rprivate-file 100% 1024KB 128.0KB/s 00:08\r\n" + b"\rsecret-other 0% 0 0.0KB/s --:-- ETA" + b"\rsecret-other 100% 1025 64.0KB/s 00:00\r\n") + for offset in range(0, len(wire), fragment): + meter.feed(wire[offset:offset + fragment]) + self.assertIn(("uploading", 524288, 1049601, 131072), reports) + self.assertEqual(reports[-1], ("uploading", 1049601, 1049601, 65536)) + self.assertEqual(meter.index, 2) + self.assertEqual([p[1] for p in reports], sorted(p[1] for p in reports)) + self.assertNotIn("private-file", repr(reports)) + self.assertNotIn("secret-other", repr(reports)) + + def test_unrecognized_output_is_not_displayed_and_buffer_is_bounded(self): + reports = [] + meter = paste.SCPMeter([10], lambda *args: reports.append(args)) + meter.feed(b"private error " * 10000 + b" 999% 5 1.0KB/s 00:00\n") + self.assertEqual(reports, []) + self.assertLessEqual(len(meter.buffer), 512) + + def test_metered_process_captures_progress_privately_and_preserves_failure_cancellation(self): + reports = [] + code = ("import os;assert os.isatty(1);assert os.tcgetpgrp(1)==os.getpgrp();" + "os.write(1,b'\\rprivate-file 100% 1025 64.0KB/s 00:00\\n')") + paste.run_metered([sys.executable, "-c", code], threading.Event(), 5, + paste.SCPMeter([1025], lambda *args: reports.append(args))) + self.assertEqual(reports[-1], ("uploading", 1025, 1025, 65536)) + with self.assertRaises(paste.PasteError): + paste.run_metered([sys.executable, "-c", "raise SystemExit(2)"], threading.Event(), 5, + paste.SCPMeter([1], lambda *_: None)) + cancel = threading.Event() + cancel.set() + with self.assertRaises(paste.PasteError): + paste.run_metered([sys.executable, "-c", "import time;time.sleep(30)"], cancel, 5, + paste.SCPMeter([1], lambda *_: None)) + + def test_display_restores_split_remote_title_and_never_changes_terminal_cells(self): + output = [] + display = paste.UploadDisplay(output.append) + for byte in b"\x1b]2;remote app title\x1b\\": + display.observe(bytes([byte])) + with mock.patch.object(paste.time, "monotonic", return_value=10): + display.start(1048576) + with mock.patch.object(paste.time, "monotonic", return_value=13): + display.update("uploading", 524288, 1048576, 131072) + display.render() + display.render() # Throttled, not a second display update. + self.assertEqual(len(output), 2) + self.assertIn(b"Connecting", output[0]) + self.assertIn(b"Uploading 50% | 512.0 KiB/1.0 MiB | 128.0 KiB/s | 3s", output[1]) + self.assertIn(b"\x1b]9;4;1;50\x1b\\", output[1]) + display.observe(b"\x1b]0;new remote title\x07") + display.finish() + self.assertEqual(output[-1], b"\x1b]9;4;0\x1b\\\x1b]2;new remote title\x1b\\") + display.finish() + self.assertEqual(len(output), 3) + self.assertTrue(all(b"\n" not in item and b"\r" not in item for item in output)) + + +HARNESS = r''' +import os, runpy, sys, time, json +h = runpy.run_path(sys.argv[1]) +paths, remote, mode, fail = json.loads(sys.argv[2]) +class Upload: + def upload(self, files, cancel, progress): + assert files == paths + progress('uploading',512,1024,256) + time.sleep(0.1) + if fail == 'cancel': + assert cancel.wait(5) + if fail: + raise h['PasteError']('synthetic failure') + return remote.encode() +child = """import os,tty,base64 +tty.setraw(0) +os.write(1, %r + b'CHILD_READY') +data=b'' +while not data.endswith(b'\\r'): + part=os.read(0,65536) + if not part: break + data+=part +os.write(1,b'RECEIVED:' + base64.b64encode(data) + b':DONE') +raise SystemExit(7) +""" % (h['ENABLE'] if mode else h['DISABLE']) +raise SystemExit(h['relay']([sys.executable,'-c',child], lambda: paths, Upload())) +''' + + +class RelayTests(unittest.TestCase): + def test_resize_and_signal_shutdown_restore_terminal(self): + child = r''' +import fcntl,os,signal,struct,termios,tty +tty.setraw(0) +def resized(*_): + rows,cols,_,_=struct.unpack('HHHH',fcntl.ioctl(0,termios.TIOCGWINSZ,bytes(8))) + os.write(1,('SIZE:%d,%d;'%(rows,cols)).encode()) +signal.signal(signal.SIGWINCH,resized) +resized() +while True: signal.pause() +''' + harness = "import runpy,sys;h=runpy.run_path(sys.argv[1]);h['relay']([sys.executable,'-c',sys.argv[2]],lambda:[],None)" + master, slave = pty.openpty() + original = termios.tcgetattr(slave) + import fcntl + fcntl.ioctl(slave, termios.TIOCSWINSZ, struct.pack("HHHH", 24, 80, 0, 0)) + proc = subprocess.Popen([sys.executable, "-c", harness, str(SCRIPT), child], + stdin=slave, stdout=slave, stderr=slave) + output = bytearray() + + def until(marker): + deadline = time.monotonic() + 5 + while marker not in output: + self.assertLess(time.monotonic(), deadline, "Resize was not forwarded") + if select.select([master], [], [], 0.1)[0]: + output.extend(os.read(master, 65536)) + try: + until(b"SIZE:24,80;") + fcntl.ioctl(slave, termios.TIOCSWINSZ, struct.pack("HHHH", 31, 110, 0, 0)) + proc.send_signal(signal.SIGWINCH) + until(b"SIZE:31,110;") + proc.send_signal(signal.SIGTERM) + self.assertEqual(proc.wait(timeout=5), 128 + signal.SIGTERM) + restored = termios.tcgetattr(slave) + restored[3] &= ~getattr(termios, "PENDIN", 0) + original[3] &= ~getattr(termios, "PENDIN", 0) + self.assertEqual(restored, original) + finally: + if proc.poll() is None: + proc.kill() + proc.wait() + os.close(master) + os.close(slave) + + def test_real_pty_upload_order_mouse_text_failure_exit_status_and_restoration(self): + with tempfile.TemporaryDirectory() as tmp: + file = Path(tmp) / "paste space 中文.txt" + file.write_text("synthetic fixture") + mouse = b"\x1b[<2;2;3M\x1b[<2;2;3m\x1b[<35;3;4M" + for mode, fail, ordinary in ((False, False, False), (True, False, False), + (True, True, False), (False, False, True), + (True, False, True), (True, 'cancel', False)): + with self.subTest(mode=mode, fail=fail, ordinary=ordinary): + master, slave = pty.openpty() + original = termios.tcgetattr(slave) + remote = shlex.quote("/home/test/.local/share/uuremote/uploads/paste.test/space 中文.txt") + config = json.dumps([[str(file)], remote, mode, fail]) + proc = subprocess.Popen([sys.executable, "-c", HARNESS, str(SCRIPT), config], + stdin=slave, stdout=slave, stderr=slave) + output = bytearray() + try: + deadline = time.monotonic() + 10 + while b"CHILD_READY" not in output: + self.assertLess(time.monotonic(), deadline, "PTY harness did not start") + if select.select([master], [], [], 0.1)[0]: + output.extend(os.read(master, 65536)) + payload = b"ordinary\ntext" if ordinary else shlex.quote(str(file)).encode() + wire = mouse + paste.START + payload + paste.END + wire += b"\x03\r" if fail == 'cancel' else b"\r" + for byte in wire: + os.write(master, bytes([byte])) + while proc.poll() is None or select.select([master], [], [], 0)[0]: + self.assertLess(time.monotonic(), deadline, "PTY relay did not exit") + if select.select([master], [], [], 0.1)[0]: + try: + chunk = os.read(master, 65536) + except OSError as error: + if error.errno == errno.EIO: + break + raise + if not chunk: + break + output.extend(chunk) + self.assertEqual(proc.wait(timeout=2), 7) + encoded = bytes(output).split(b"RECEIVED:", 1)[1].split(b":DONE", 1)[0] + expected = b"" if fail else paste.paste_bytes(payload if ordinary else remote.encode(), mode) + interrupt = b"\x03" if fail == 'cancel' else b"" + self.assertEqual(base64.b64decode(encoded), mouse + expected + interrupt + b"\r") + restored = termios.tcgetattr(slave) + # macOS sets PENDIN when restoring canonical input. It + # is kernel bookkeeping, not an unrestored user mode. + restored[3] &= ~getattr(termios, "PENDIN", 0) + original[3] &= ~getattr(termios, "PENDIN", 0) + self.assertEqual(restored, original) + if fail: + self.assertNotIn(str(file).encode(), output) + if not ordinary: + self.assertIn(b"UU upload: Connecting", output) + self.assertIn(b"\x1b]9;4;0\x1b\\", output) + if fail == 'cancel': + self.assertIn(b"UU upload: Cancelling", output) + finally: + if proc.poll() is None: + proc.kill() + proc.wait() + os.close(master) + os.close(slave) + + +@unittest.skipUnless(os.environ.get("UU_PASTE_TEST_HOST"), "set UU_PASTE_TEST_HOST for a real mapped SSH test") +class MappedSSHTests(unittest.TestCase): + def test_live_upload_reports_intermediate_progress_and_verified_completion(self): + host = os.environ["UU_PASTE_TEST_HOST"] + uploader = paste.Uploader(os.environ.get("UU_PASTE_TEST_CONFIG"), host) + uploader.scp.extend(["-l", "1024"]) # Deliberately slow a synthetic transfer. + reports = [] + with tempfile.TemporaryDirectory() as tmp: + source = Path(tmp) / "private progress 中文.bin" + source.write_bytes(os.urandom(1024 * 1024)) + paths = shlex.split(uploader.upload([str(source)], threading.Event(), + lambda *args: reports.append(args)).decode()) + try: + total = source.stat().st_size + self.assertEqual(reports[0], ("connecting", 0, total, 0)) + self.assertTrue(any(0 < done < total and speed > 0 + for stage, done, size, speed in reports if stage == "uploading")) + self.assertEqual(reports[-1], ("finishing", total, total, 0)) + self.assertNotIn(source.name, repr(reports)) + remote = paste.run_private([*uploader.ssh, "sha256sum -- " + shlex.quote(paths[0])], + threading.Event(), 30) + self.assertEqual(remote.split()[0].decode(), hashlib.sha256(source.read_bytes()).hexdigest()) + finally: + paste.run_private([*uploader.ssh, "rm -rf -- " + shlex.quote(str(Path(paths[0]).parent))], + threading.Event(), 30) + + def test_paste_through_real_pty_and_uu_ssh_opens_uploaded_files(self): + host = os.environ["UU_PASTE_TEST_HOST"] + config = os.environ.get("UU_PASTE_TEST_CONFIG") + with tempfile.TemporaryDirectory() as tmp: + files = [Path(tmp) / "copied file 中文.bin", Path(tmp) / "literal'$(echo nope);.bin"] + for file in files: + file.write_bytes(os.urandom(65569)) + hashes = [hashlib.sha256(f.read_bytes()).hexdigest() for f in files] + mouse = b"\x1b[<2;2;3M\x1b[<2;2;3m\x1b[<35;3;4M" + remote = r''' +import os,tty,shlex,hashlib,json,shutil +from pathlib import Path +tty.setraw(0) +os.write(1,b'\x1b[?2004hLIVE_READY') +data=b'' +while not data.endswith(b'\r'): + data+=os.read(0,65536) +mouse=b'\x1b[<2;2;3M\x1b[<2;2;3m\x1b[<35;3;4M' +assert data.startswith(mouse+b'\x1b[200~') and data.endswith(b'\x1b[201~\r') +paths=shlex.split(data[len(mouse)+6:-7].decode()) +assert len(paths)==2 +hashes=[hashlib.sha256(Path(p).read_bytes()).hexdigest() for p in paths] +for directory in {Path(p).parent for p in paths}: + assert directory.parent==Path.home()/'.local/share/uuremote/uploads' + assert directory.name.startswith('paste.') + shutil.rmtree(directory) +os.write(1,b'LIVE_HASHES:'+json.dumps(hashes).encode()+b':DONE') +''' + harness = r''' +import runpy,sys,json +h=runpy.run_path(sys.argv[1]) +host,config,paths,remote=json.loads(sys.argv[2]) +uploader=h['Uploader'](config,host) +common=['-F',config] if config else [] +raise SystemExit(h['relay'](['/usr/bin/ssh',*common,'-tt',host,remote],lambda:paths,uploader)) +''' + args = json.dumps([host, config, [str(p) for p in files], "python3 -c " + shlex.quote(remote)]) + master, slave = pty.openpty() + process = subprocess.Popen([sys.executable, "-c", harness, str(SCRIPT), args], + stdin=slave, stdout=slave, stderr=slave) + output = bytearray() + try: + deadline = time.monotonic() + 60 + sent = False + while process.poll() is None or select.select([master], [], [], 0)[0]: + self.assertLess(time.monotonic(), deadline, "Live paste timed out") + if select.select([master], [], [], 0.1)[0]: + output.extend(os.read(master, 65536)) + if b"LIVE_READY" in output and not sent: + payload = shlex.join([str(p) for p in files]).encode() + os.write(master, mouse + paste.START + payload + paste.END + b"\r") + sent = True + self.assertEqual(process.wait(timeout=2), 0) + received = bytes(output).split(b"LIVE_HASHES:", 1)[1].split(b":DONE", 1)[0] + self.assertEqual(json.loads(received), hashes) + finally: + if process.poll() is None: + process.kill() + process.wait() + os.close(master) + os.close(slave) + + def test_real_upload_roundtrip_binary_unicode_and_shell_metacharacters(self): + host = os.environ["UU_PASTE_TEST_HOST"] + config = os.environ.get("UU_PASTE_TEST_CONFIG") + uploader = paste.Uploader(config, host) + with tempfile.TemporaryDirectory() as tmp: + root = Path(tmp) + files = [root / "space 中文.bin", root / "literal'$(echo nope);.bin"] + for file in files: + file.write_bytes(os.urandom(65569)) + paths = shlex.split(uploader.upload([str(f) for f in files], threading.Event()).decode()) + try: + for index, (source, remote) in enumerate(zip(files, paths)): + dest = root / ("download-" + str(index)) + paste.run_private([*uploader.scp, f"{host}:{remote}", str(dest)], threading.Event(), 60) + self.assertEqual(hashlib.sha256(source.read_bytes()).digest(), + hashlib.sha256(dest.read_bytes()).digest()) + directory = str(Path(paths[0]).parent) + mode = paste.run_private([*uploader.ssh, "stat -c %a -- " + shlex.quote(directory)], + threading.Event(), 30) + self.assertEqual(mode.strip(), b"700") + finally: + paste.run_private([*uploader.ssh, "rm -rf -- " + shlex.quote(str(Path(paths[0]).parent))], + threading.Event(), 30) + + +if __name__ == "__main__": + unittest.main() diff --git a/contrib/macos-ssh/uu-ssh-paste b/contrib/macos-ssh/uu-ssh-paste new file mode 100755 index 0000000..67cc9dd --- /dev/null +++ b/contrib/macos-ssh/uu-ssh-paste @@ -0,0 +1,594 @@ +#!/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)