mirror of
https://github.com/VallierDev/uu-remote-linux.git
synced 2026-11-16 08:50:40 +01:00
contrib: macOS SSH companion for Finder file paste uploads (#45)
* Add macOS SSH companion for Finder file paste uploads * Show measured upload progress in Ghostty title and progress bar
This commit is contained in:
9 files changed
+1249
No files matched your search
@@ -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:
|
||||
|
||||
@@ -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
|
||||
|
||||
@@ -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
|
||||
|
||||
@@ -0,0 +1 @@
|
||||
__pycache__/
|
||||
@@ -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.
|
||||
@@ -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)
|
||||
}
|
||||
Executable
+27
@@ -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.'
|
||||
@@ -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()
|
||||
Executable
+594
@@ -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)
|
||||
Reference in new issue
Block a user