Compare commits

...
11 Commits
Author SHA1 Message Date
VallierDevandClaude Opus 5.5 89abae2369 Release v0.2.19: headless Wayland, custom bitrate, show and login fixes
Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-10-20 16:34:37 +08:00
VallierDevandClaude Opus 5.5 0afc602e66 Login polling backoff and a hint for instantly expiring QR codes (#68); bitrate unit safeguard; doctor wording
- Never spin on immediate unchanged status answers or transport errors (2 s backoff); repeated
  QR codes that expire within seconds back off exponentially and point to re-registering the
  device identity, which recovered a flagged device in #68.
- Custom bitrate field 8 is bit/s (#67); values that can only be Mbit/s or kbit/s are scaled
  instead of capping the encoder at 1 kbit/s.
- doctor: without DISPLAY the X11 engine still tries :0/:1, so the #66 warning says that.

Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-10-20 16:29:57 +08:00
ZoranandJuanZoran 762cfccc44 Custom video bitrate is bits per second (#67)
Co-authored-by: JuanZoran <[email protected]>
2026-10-20 16:28:56 +08:00
axlrose 9520b69730 doctor: say so when the session has no screen to capture (#66)
Without DISPLAY and without WAYLAND_DISPLAY the desktop backend cannot
capture anything: the host logs 'Desktop unavailable ... x11_init failed'.
The report named X11 as the selected backend and nothing else, which reads
like a working setup. Name the missing display and note that the terminal,
file transfer and port mapping tools still work.
2026-10-20 16:28:51 +08:00
axlrose c45e4749b5 Wayland: a failed output-power handshake must not block screencopy (#65)
Output power management is optional: the engine comment already says so, but
uu_wl_wake() only tolerated a *missing* power manager. When the compositor
offers zwlr_output_power_manager_v1 and then refuses the mode (headless
outputs, outputs without DPMS), power_failed is set and the function
reported an error. capture::keep_display_awake() propagates that error and
video.rs aborts the whole capture task with '?', so a client could connect
but never received a frame.

Treat a failed power handshake like a missing one: skip waking the screen
and keep streaming.
2026-10-20 16:28:46 +08:00
VallierDevandClaude Opus 5.5 c1b8bfe1b3 show: report a skipped or crash-looping service instead of waiting 30 s (#62); document FFmpeg 6.x for inproc-av (#63)
systemctl start returns 0 when the unit is skipped by a Condition or keeps crashing under
Restart=; show now reads ActiveState/SubState/ConditionResult while waiting and names the real
problem. ffmpeg-sys-next's build script runs before ours, so FFmpeg >= 7 cannot be caught in
build.rs; the README and AGENTS state the 6.x requirement next to the build commands.

Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-10-20 15:24:33 +08:00
VallierDevandClaude Opus 5.5 03d2311649 Release v0.2.18: Debian packages, experimental WOL helper
Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-10-20 12:48:13 +08:00
VallierDevandClaude Opus 5.5 5949314e55 Experimental WOL helper (UU_WOL_HELPER=1); doctor keeps logs quiet
Mirrors the official Windows host (GameViewerServer reportLanInfo / PushMessageHandler::wakeOnLan /
send_wol): report the LAN identity after sign-in and answer wake_on_lan pushes with a magic packet
to the target's subnet broadcast. Field names come from the official log strings; off by default
and unverified end to end. wake_on_lan push key names are always logged for evidence.

Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-10-20 12:43:13 +08:00
VallierDevandClaude Opus 5.5 8389fc4eed Debian package: binaries, engine plugins, systemd user unit, menu entries
Built and install-tested in the release workflow (and CI) with dependencies taken from the
binaries by dpkg-shlibdeps. The unit starts with graphical-session.target; uinput access stays
opt-in (the udev rule ships under /usr/share/doc).

Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-10-20 12:38:39 +08:00
VallierDevandClaude Opus 5.5 b8de665593 Release v0.2.17: doctor diagnostic report
Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-10-20 12:34:06 +08:00
VallierDevandClaude Opus 5.5 554cbe806a doctor: one paste-safe diagnostic report for issues
Session, selected backend (and the X11-inside-Wayland trap), engine plugin load results, uinput
and render-node access, FFmpeg encoders/version, the default codec, sign-in and service state.
Prints booleans, names and versions only; home directory and user name are masked. The issue
template and READMEs ask for it.

Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-10-20 12:30:01 +08:00
21 changed files with 646 additions and 27 deletions

No files matched your search

+1
View File
@@ -37,6 +37,7 @@ body:
```sh
{
echo "== doctor (v0.2.17+)"; uuremote-server doctor
echo "== 系统"; grep PRETTY_NAME /etc/os-release; uname -rm
echo "== 桌面"; echo "session=$XDG_SESSION_TYPE desktop=$XDG_CURRENT_DESKTOP"
echo "== 显示器"; xrandr --listmonitors 2>/dev/null
+8
View File
@@ -35,6 +35,14 @@ jobs:
run: |
cargo build --locked --features wayland,portal,engine-plugins --bin uuremote-server
test -f target/debug/libuu-wayland.so
- name: Debian package installs
run: |
packaging/deb/build-deb.sh 0.0.0~ci target/debug /tmp/deb
dpkg-deb -I /tmp/deb/*.deb | grep -E 'Depends|Recommends'
sudo apt-get install -y /tmp/deb/*.deb
uuremote-server --help | head -1
test -f /usr/lib/uu-remote-linux/libuu-wayland.so
systemd-analyze verify /usr/lib/systemd/user/uuremote-native.service
test-viewer:
runs-on: ubuntu-22.04
+13 -1
View File
@@ -69,10 +69,20 @@ jobs:
cp -r contrib "$name/"
tar czf "$name.tar.gz" "$name"
sha256sum "$name.tar.gz" > "$name.tar.gz.sha256"
- name: Debian package
run: |
packaging/deb/build-deb.sh "${GITHUB_REF_NAME#v}" target/release .
deb=$(ls uu-remote-linux_*.deb)
sha256sum "$deb" > "$deb.sha256"
sudo apt-get install -y "./$deb"
uuremote-server --help | head -1
systemd-analyze verify /usr/lib/systemd/user/uuremote-native.service
- uses: actions/upload-artifact@v4
with:
name: package-${{ matrix.arch }}
path: uu-remote-linux-*.tar.gz*
path: |
uu-remote-linux-*.tar.gz*
uu-remote-linux_*.deb*
# One publisher, so the matrix legs never race to create the release.
release:
@@ -90,6 +100,8 @@ jobs:
files: |
uu-remote-linux-*.tar.gz
uu-remote-linux-*.tar.gz.sha256
uu-remote-linux_*.deb
uu-remote-linux_*.deb.sha256
# Headless NAS image (docker/), built from the release tarball published by the job above.
docker:
+5 -2
View File
@@ -39,7 +39,8 @@ Dependencies (Ubuntu/Debian):
sudo apt install build-essential pkg-config \
libx11-dev libxext-dev libxtst-dev libxfixes-dev libavcodec-dev libavformat-dev libavdevice-dev libswscale-dev libclang-dev libgtk-3-dev ffmpeg
# --features inproc-av: libavcodec-dev libavformat-dev libavdevice-dev libswscale-dev libclang-dev
# (FFmpeg 6.x; in-process capture/encoding, Ubuntu 24.04 ships it)
# (FFmpeg 6.x only; in-process capture/encoding, Ubuntu 24.04 ships it. FFmpeg >= 7
# fails in ffmpeg-sys-next with "avfft.h file not found", before our build.rs runs)
# --features wayland: libwayland-dev libxkbcommon-dev wl-clipboard
# --features wayland,portal: + libglib2.0-dev libpipewire-0.3-dev libei-dev (libei >= 1.1)
```
@@ -117,6 +118,7 @@ viewer does not reconnect them automatically.
| `UU_AUDIO=0`, `UU_AUDIO_SOURCE` | disable sound / choose the Pulse source (default `@DEFAULT_MONITOR@`) |
| `UU_LOGIN_WINDOW=0` | don't auto-open the login window |
| `UU_ENGINE_DIR` | directory holding `libuu-wayland.so` / `libuu-portal.so` (`--features engine-plugins`, used by release packages: engines are dlopen'ed only on Wayland sessions; also searched next to the binary, `../lib/uu-remote-linux`, `~/.local/lib/uu-remote-linux`, `/usr/lib/uu-remote-linux`) |
| `UU_WOL_HELPER=1` | experimental: report LAN info (`api-ipv4…/api/v1/device/wake_on_lan/info` {mac, ip, subnet_mask}) after sign-in and answer `wake_on_lan` pushes (`target_device` {mac, ip, subnet_mask}) with a magic packet, like the official Windows host (field names from its log strings; not verified end to end). `wake_on_lan` push key names are always logged |
| `UU_USE_PROXY=1` | honor HTTP/SOCKS proxy env vars; cloud API clients bypass env proxies by default |
| `UU_REMOTE_ASSIST=0`, `UU_ASSIST_ALLOW=1`, `UU_ASSIST_UI=tty`, `UU_ASSIST_DEBUG=1` | disable assistance / allow at start / terminal UI for `assist` / include the server's short error message in assist errors |
@@ -152,7 +154,8 @@ every 60 s.
| `src/viewer_main.rs`, `src/viewer/` | experimental viewer (`--features native-viewer,viewer-sdl`): cloud join, WebRTC offer side, SDL desktop window (ffmpeg CLI decode), files/terminal/portmap/power/assist tools, device removal (`POST /api/v1/device/{id}/unbind`, verified live; shared devices use `/api/v1/device/share/{id}/unbind`, strings only), GTK launcher |
| `c_engine/viewer_window.c`, `c_engine/viewer_tools.c` | viewer GTK launcher and tool windows (files, port mapping, terminal list) |
Diagnostic subcommands: `login [--no-gui]`, `unlock-check` (password on stdin, prints only accepted/rejected),
Diagnostic subcommands: `doctor` (paste-safe report: session, selected backend, engine plugins, uinput, encoders,
default codec, sign-in/service state; booleans and names only), `login [--no-gui]`, `unlock-check` (password on stdin, prints only accepted/rejected),
`desktop-probe [new.png]`, `desktop-video-probe` (`UU_PROBE_FPS`, `UU_PROBE_FRAMES`, `UU_PROBE_QUALITY` 1-5 = viewer bitrate preset, 5 auto; `UU_PROBE_INPUT` fixed video/image sequence, `UU_PROBE_LOOP=1` repeats), `wayland-input-probe`, `clipboard-acceptance`,
`portal-acceptance`, `help`. Unknown arguments exit with code 2. Builds up to v0.1.0 did **not** reject them and
started a second full host server instead, so check that a subcommand exists in the binary you run.
Generated
+1 -1
View File
@@ -2741,7 +2741,7 @@ checksum = "06abde3611657adf66d383f00b093d7faecc7fa57071cce2578660c9f1010821"
[[package]]
name = "uu-remote-linux"
version = "0.2.16"
version = "0.2.19"
dependencies = [
"async-trait",
"base64 0.22.1",
+1 -1
View File
@@ -1,6 +1,6 @@
[package]
name = "uu-remote-linux"
version = "0.2.16"
version = "0.2.19"
edition = "2021"
default-run = "uuremote-server"
authors = ["uu-remote-linux contributors"]
+22 -2
View File
@@ -77,7 +77,8 @@ authorized session. Independent file/terminal tool peers do not reset input.
| GNOME / KDE Plasma | Wayland (xdg-desktop-portal) | 🧪 Experimental; validation scope and limits below | `--features wayland,portal` |
The GNOME Wayland Portal/EIS path has been checked for video and mouse/keyboard input on Ubuntu 26.04, GNOME 50, with one 4K screen at 200% scale; auto unlock after a cold locked connection is verified with the official Mac and iPhone 4.42.0 viewers, while other lock recovery and reconnection still need hardware acceptance testing. Apart from that path and GNOME on X11, desktop testing has primarily used virtual machines. If something goes wrong on
real hardware, please [open an issue](../../issues) with your distribution, desktop, GPU and the relevant lines from
real hardware, please [open an issue](../../issues) with the output of `uuremote-server doctor` (v0.2.17+; session, backend,
plugins, permissions and encoders only, no account data, tokens or addresses) and the relevant lines from
`journalctl --user -u uuremote-native.service`.
Wayland limits: captures one screen by default; Hyprland can enable monitor switching as described below. Resolution is fixed. The native Hyprland backend now pipelines two shm screencopy buffers and passes the viewer's requested fps to both capture pacing and the encoder. Actual fps remains limited by the compositor, rendering and readback (the old serial path measured about 16–22 fps at 2560x1600; the pipeline is VM-measured only, not a hardware guarantee). The portal backend does not support dynamic resolution; see below for GNOME wake and lock recovery; the clipboard syncs while the viewer's remote window has focus. On the first connection the desktop asks for "Remote Desktop / Screen Sharing"
@@ -130,7 +131,18 @@ Switching reuses one video track and pauses input until the new source sends a f
### 0. Prebuilt release package (recommended, x86_64 / aarch64)
Download `uu-remote-linux-<version>-x86_64-linux.tar.gz` (ARM64: `aarch64-linux`) from [Releases](../../releases/latest), extract it, then:
**Ubuntu / Debian (v0.2.18+)**: download `uu-remote-linux_<version>_amd64.deb` (ARM64: `arm64`), then:
```sh
sudo apt install ./uu-remote-linux_<version>_amd64.deb
uuremote-server login # scan the QR code with the UU Remote app
systemctl --user enable --now uuremote-native.service # start with the graphical session
```
The deb installs the binaries, plugins, a systemd user unit and menu entries; uinput access stays opt-in (step 5).
GNOME and KDE pass the display environment to the unit; on desktops that don't (e.g. Xfce) add `DISPLAY` as in step 4.
**Other distributions**: download `uu-remote-linux-<version>-x86_64-linux.tar.gz` (ARM64: `aarch64-linux`) from [Releases](../../releases/latest), extract it, then:
```sh
install -Dm755 uuremote-server ~/.local/bin/uuremote-server
@@ -175,6 +187,11 @@ cargo build --release --features wayland # + Hyprland
cargo build --release --features wayland,portal # + GNOME/KDE on Wayland
```
The optional `--features inproc-av` (in-process encoding) and the viewer's `viewer-ffmpeg` support **FFmpeg 6.x only**
(`pkg-config --modversion libavcodec` = 60.x). FFmpeg 7+ fails inside the `ffmpeg-sys-next` dependency with
`avfft.h file not found`; its build script runs before this project's, so no clearer check is possible (#63). The default
build and the release packages need neither feature.
### 3. Log in
Run inside your graphical session:
@@ -321,11 +338,14 @@ Common environment variables:
| `UU_ASSIST_ALLOW=1` | Allow remote assistance at start (overrides the saved switch) |
| `UU_LOGIN_WINDOW=0` | Do not open the login window automatically when credentials are missing |
| `UU_PORT_MAPPING=0` | Disable port mapping (the official host's controlled-side switch) |
| `UU_WOL_HELPER=1` | Experimental: act as a remote-boot helper like the official Windows host — report this host's LAN info after sign-in and send a magic packet to the LAN when the cloud asks to wake a PC (not verified end to end) |
| `UU_USE_PROXY=1` | Honor HTTP/SOCKS proxy environment variables; by default proxies are ignored and NetEase servers are reached directly |
Host settings such as "lock after remote session" and "mute host" are stored in
`~/.config/uuremote/host_settings.json`.
Custom bitrate follows the Mbps value selected in the client; for example, 1 Mbps sets an encoder cap of 1000 kbit/s.
With external FFmpeg CPU encoding, the bitrate presets (Original / Ultra / HD / custom) use average bitrate (ABR) to avoid gray keyframes at 4K and low bitrates; Auto keeps constant rate factor (CRF).
## Let an AI agent install or develop it
+20 -2
View File
@@ -71,7 +71,7 @@ Portal 仅作用于本服务获授权的会话。文件传输、终端等独立
最后一列是源码编译方式;Release 预编译包已包含全部后端,直接使用即可(见[安装](#0-直接用-release-预编译包推荐x86_64))。
GNOME Wayland 的 Portal/EIS 路径已在 Ubuntu 26.04、GNOME 50、单屏 4K/200% 缩放下验证画面和键鼠;锁屏冷连接自动解锁已用 Mac 和 iPhone 4.42.0 客户端实机验证,其余锁屏恢复及重连仍待验收。除 GNOME 的上述路径和 X11 外,其余桌面目前主要在虚拟机里测试。如果你在真机上遇到问题,欢迎[提交 issue](../../issues),
请附上发行版、桌面环境、显卡型号和 `journalctl --user -u uuremote-native.service` 里的相关日志。
请附上 `uuremote-server doctor` 的输出(v0.2.17 起;只含会话、后端、插件、权限、编码器等状态,不含账号、令牌或地址,可直接粘贴)和 `journalctl --user -u uuremote-native.service` 里的相关日志。
Wayland 下的限制:默认采集单屏,Hyprland 可按上文启用切屏;分辨率固定;Hyprland 原生后端默认使用双缓冲流水线 shm screencopy,控制端帧率设置会同步到采集节拍和编码器,但实际帧率仍受合成器、渲染和读回速度限制(旧串行路径在 2560x1600 曾测得约 16~22 帧;流水线只在虚拟机里测量过,不代表实机保证);portal 后端暂不支持动态分辨率;GNOME 的屏幕唤醒与锁屏恢复见下;剪贴板只在控制端的远控窗口处于前台时同步。
@@ -117,7 +117,18 @@ GNOME Portal 的控制通道不再等待授权窗口或第一帧画面:先通
### 0. 直接用 Release 预编译包(推荐,x86_64 / aarch64)
从 [Releases](../../releases/latest) 下载 `uu-remote-linux-<版本>-x86_64-linux.tar.gz`(ARM64 选 `aarch64-linux`),解压后:
**Ubuntu / Debian(v0.2.18 起)**:下载 `uu-remote-linux_<版本>_amd64.deb`(ARM64 选 `arm64`)后:
```sh
sudo apt install ./uu-remote-linux_<版本>_amd64.deb
uuremote-server login # 用 UU 远程 App 扫码
systemctl --user enable --now uuremote-native.service # 随图形会话启动
```
deb 会安装程序、插件、用户级 systemd 服务和应用菜单图标;uinput 权限不会自动开启(见第 5 步)。
GNOME / KDE 会把显示环境自动传给服务;Xfce 等不传的桌面需按第 4 步补 `DISPLAY`。
**其他发行版**:从 [Releases](../../releases/latest) 下载 `uu-remote-linux-<版本>-x86_64-linux.tar.gz`(ARM64 选 `aarch64-linux`),解压后:
```sh
install -Dm755 uuremote-server ~/.local/bin/uuremote-server
@@ -160,6 +171,10 @@ cargo build --release --features wayland # + Hyprland
cargo build --release --features wayland,portal # + GNOME/KDE Wayland
```
可选的 `--features inproc-av`(进程内编码)和控制端的 `viewer-ffmpeg` 只支持 **FFmpeg 6.x**(`pkg-config --modversion libavcodec` 为 60.x)。
FFmpeg 7 及以上会在依赖 `ffmpeg-sys-next` 里报 `avfft.h file not found`——它的构建脚本先于本项目运行,所以无法提前给出更清楚的提示(#63)。
默认构建和预编译包都不需要这两个特性。
### 3. 登录
在图形桌面里运行:
@@ -292,10 +307,13 @@ systemctl --user restart uuremote-native.service
| `UU_REMOTE_ASSIST=0` | 关闭远程协助(未登录时也不再以访客身份提供协助) |
| `UU_ASSIST_ALLOW=1` | 启动时就允许他人远程协助(覆盖窗口里保存的开关状态) |
| `UU_PORT_MAPPING=0` | 关闭端口映射(对应官方被控端的开关) |
| `UU_WOL_HELPER=1` | 实验性:让这台主机像官方 Windows 被控端一样充当「远程开机」辅助设备——登录后向网易上报本机局域网信息,收到云端唤醒请求时向同一局域网发送唤醒包(未经端到端验证) |
| `UU_USE_PROXY=1` | 使用环境变量里的 HTTP/SOCKS 代理;默认忽略代理、直连网易服务器 |
「远程结束后自动锁屏」「静音运行」等设置保存在 `~/.config/uuremote/host_settings.json`。
自定义码率按客户端选择的 Mbps 生效,例如 1 Mbps 对应 1000 kbit/s 的编码上限。
选择码率档(原画 / 超清 / 高清 / 自定义)时,外部 FFmpeg 的 CPU 编码以平均码率(ABR)为目标,避免 4K 低码率下关键帧发灰;「自动」档仍使用恒定质量(CRF)。
本地编码诊断 `desktop-video-probe [output.h264]` 可设置 `UU_PROBE_FPS`、`UU_PROBE_FRAMES`(默认 5)和 `UU_PROBE_QUALITY`(1–5);设置 `UU_PROBE_INPUT=clip.y4m`(也支持 `.mp4`、`frames/%05d.png`)可绕过桌面采集,以相同的生产 FFmpeg 编码参数测量固定输入并打印分辨率和编码统计,`UU_PROBE_LOOP=1` 循环到指定帧数,输入无法打开或帧数不足时以非零状态退出(固定输入始终使用外部 FFmpeg 管线)。
+5 -1
View File
@@ -601,7 +601,11 @@ end:
int uu_wl_wake(void) {
pthread_mutex_lock(&lock); int result=-1;
/* Output power management is optional; missing it must not block screencopy. */
if(initialized && !power) result=0;
if(initialized && (!power || power_failed)) {
/* No power manager, or the compositor refused the mode (outputs without DPMS,
headless outputs): streaming continues, the screen simply stays as it is. */
result=0;
}
if(initialized && power && !power_failed) {
zwlr_output_power_v1_set_mode(power,ZWLR_OUTPUT_POWER_V1_MODE_ON);
if(sync_display()==0 && !power_failed) result=0;
+1 -1
View File
@@ -1,7 +1,7 @@
# Unofficial UU Remote Linux host in a container, for NAS boxes (Synology DSM, etc.) without a desktop.
# Headless mode: file transfer, terminal and port mapping; no remote desktop. Uses the published release binary.
FROM ubuntu:24.04
ARG VERSION=v0.2.16
ARG VERSION=v0.2.19
LABEL org.opencontainers.image.source="https://github.com/VallierDev/uu-remote-linux" \
org.opencontainers.image.description="Unofficial UU Remote Linux host, headless (file transfer, terminal, port mapping)" \
org.opencontainers.image.licenses="GPL-3.0"
+14
View File
@@ -0,0 +1,14 @@
新增 `uuremote-server doctor` 一键诊断。/ New `uuremote-server doctor` diagnostic report.
### 新增 / Added
- **`uuremote-server doctor`**:一次输出提 issue 需要的状态——会话类型与桌面、最终选中的后端(含「Wayland 会话里用了 X11 后端会黑屏」的提醒)、
Wayland / portal 插件能否加载及缺什么库、`/dev/uinput` 与显卡 render 节点权限、FFmpeg 可用编码器和版本、默认编码(H.264 / H.265)、
是否已登录、服务状态和重复进程。只输出布尔值、名称和版本,主目录和用户名会被替换,不含账号 ID、令牌、IP、MAC 或文件内容,
可以直接贴到 issue。issue 模板已改为先运行它。
- `uuremote-server doctor` prints a paste-safe report (session, backend, plugins, permissions, encoders, default codec, sign-in and
service state) with no ids, tokens, addresses or file contents.
### 下载 / Download
`uu-remote-linux-v0.2.17-x86_64-linux.tar.gz` / `uu-remote-linux-v0.2.17-aarch64-linux.tar.gz`,或 `docker pull ghcr.io/vallierdev/uu-remote-linux:v0.2.17`(x86_64)。
**非官方项目,与网易无关。** / **Unofficial, not affiliated with NetEase.**
+25
View File
@@ -0,0 +1,25 @@
Ubuntu / Debian 安装包(.deb);实验性远程开机辅助。/ Debian packages; experimental Wake-on-LAN helper.
### 新增 / Added
- **`.deb` 安装包**(amd64 / arm64):`sudo apt install ./uu-remote-linux_0.2.18_amd64.deb` 一步装好程序、两个桌面插件、
用户级 systemd 服务和应用菜单图标,依赖由 apt 自动安装。之后以桌面用户运行:
```sh
uuremote-server login
systemctl --user enable --now uuremote-native.service
```
服务随图形会话启动(GNOME / KDE 会自动传入显示环境;Xfce 等需按 README 补 `DISPLAY`)。uinput 权限不会自动开启,规则文件放在
`/usr/share/doc/uu-remote-linux/`。安装流程在 CI 的 Ubuntu 22.04 上实测(apt 安装、`--help`、systemd 单元校验);尚未在真实桌面上完整验收。
- **远程开机辅助(实验性,默认关闭,`UU_WOL_HELPER=1`)**:仿照官方 Windows 被控端,登录后向网易上报本机局域网信息,
收到云端的唤醒请求时向同一局域网发送唤醒包,让这台常开的 Linux(例如 NAS)帮你唤醒同局域网的其他电脑。
字段名来自官方程序的日志字符串,**未经端到端验证**;不开启时不上报任何局域网信息,只记录唤醒推送的字段名(不含 MAC/IP)。
- Debian packages (amd64/arm64) with the binaries, plugins, a systemd user unit and menu entries; install-tested on Ubuntu 22.04 in CI.
Experimental, opt-in Wake-on-LAN helper (`UU_WOL_HELPER=1`) modelled on the official Windows host; not verified end to end.
### 修复 / Fixed
- `uuremote-server doctor` 不再输出带完整路径的插件加载日志(路径可能含用户名)。
### 下载 / Download
`uu-remote-linux_0.2.18_amd64.deb` / `uu-remote-linux_0.2.18_arm64.deb`,或 `uu-remote-linux-v0.2.18-<x86_64|aarch64>-linux.tar.gz`,
或 `docker pull ghcr.io/vallierdev/uu-remote-linux:v0.2.18`(x86_64)。
**非官方项目,与网易无关。** / **Unofficial, not affiliated with NetEase.**
+18
View File
@@ -0,0 +1,18 @@
无头 Wayland 出画面、自定义码率、`show` 与登录体验修复。/ Headless Wayland video, custom bitrate, `show` and login fixes.
### 修复 / Fixed
- **无头 Wayland 主机连上没有画面**(#64 / #65,感谢 @axlrose):输出不支持 DPMS 时电源握手失败不再中断视频;贡献者在 sway headless 上复现并验证。
- **自定义码率单位错误**(#67,感谢 @JuanZoran):手机端自定义码率按 bit/s 发送(1 Mbps = 1000000),此前被当成 kbit/s 而触发 100 Mbps 上限,
导致大量重传、画面滞留。贡献者在 Hyprland + NVENC 上用手机实测。另外对明显是 Mbps / kbps 的小数值做了兜底换算(维护者补充,未实测)。
- **`uuremote-server show` 静默卡 30 秒**(#62,感谢 @axlrose):服务被条件跳过、反复崩溃重启或启动失败时立即报出真实原因。贡献者已用真实 systemd 单元验证。
- **登录二维码反复立即失效**(#68,感谢 @axlrose):状态轮询在服务器立即应答时不再紧循环(2 秒退避);二维码连续在几秒内失效时指数退避,
并提示可备份删除 `~/.config/uuremote/config.json` 重新登录(注册新设备身份,#68 中以此恢复)。退避逻辑未在被标记的设备上实测。
### 改进 / Improved
- `doctor`:会话里没有 `DISPLAY` / `WAYLAND_DISPLAY` 时给出提示(#66,感谢 @axlrose)。
- 文档:`inproc-av` / `viewer-ffmpeg` 只支持 FFmpeg 6.x,FFmpeg 7+ 会在依赖里报 `avfft.h file not found`(#63)。
### 下载 / Download
`uu-remote-linux_0.2.19_<amd64|arm64>.deb`,或 `uu-remote-linux-v0.2.19-<x86_64|aarch64>-linux.tar.gz`,或 `docker pull ghcr.io/vallierdev/uu-remote-linux:v0.2.19`(x86_64)。
**非官方项目,与网易无关。** / **Unofficial, not affiliated with NetEase.**
+67
View File
@@ -0,0 +1,67 @@
#!/bin/sh
# Build uu-remote-linux_<version>_<arch>.deb from release binaries.
# usage: packaging/deb/build-deb.sh VERSION BIN_DIR OUT_DIR (VERSION without the leading v)
set -eu
version=$1 bin=$2 out=$3
here=$(cd "$(dirname "$0")" && pwd) root=$(cd "$here/../.." && pwd)
case $(uname -m) in x86_64) arch=amd64 ;; aarch64) arch=arm64 ;; *) echo "unsupported arch" >&2; exit 1 ;; esac
pkg=$(mktemp -d)
trap 'rm -rf "$pkg"' EXIT
install -Dm755 "$bin/uuremote-server" "$pkg/usr/bin/uuremote-server"
[ -f "$bin/uuremote-viewer" ] && install -Dm755 "$bin/uuremote-viewer" "$pkg/usr/bin/uuremote-viewer"
for lib in libuu-wayland.so libuu-portal.so; do
[ -f "$bin/$lib" ] && install -Dm644 "$bin/$lib" "$pkg/usr/lib/uu-remote-linux/$lib"
done
install -Dm644 "$here/uuremote-native.service" "$pkg/usr/lib/systemd/user/uuremote-native.service"
install -Dm644 "$root/contrib/desktop/uu-remote-linux.desktop" "$pkg/usr/share/applications/uu-remote-linux.desktop"
[ -f "$pkg/usr/bin/uuremote-viewer" ] && install -Dm644 "$root/contrib/desktop/uu-remote-linux-viewer.desktop" "$pkg/usr/share/applications/uu-remote-linux-viewer.desktop"
install -Dm644 "$root/contrib/desktop/uu-remote-linux.svg" "$pkg/usr/share/icons/hicolor/scalable/apps/uu-remote-linux.svg"
install -Dm644 "$root/LICENSE" "$pkg/usr/share/doc/uu-remote-linux/copyright"
# uinput access is opt-in: it lets the service inject input into the whole seat.
printf '%s\n' 'KERNEL=="uinput", SUBSYSTEM=="misc", OPTIONS+="static_node=uinput", TAG+="uaccess"' \
> "$pkg/usr/share/doc/uu-remote-linux/60-uu-remote-linux-uinput.rules"
size=$(du -sk "$pkg/usr" | cut -f1)
# Library dependencies from the binaries themselves (the server hard, the viewer recommended).
shlibdeps() {
work=$(mktemp -d); mkdir "$work/debian"
printf 'Source: uu-remote-linux\n\nPackage: uu-remote-linux\nArchitecture: any\n' > "$work/debian/control"
(cd "$work" && dpkg-shlibdeps -O --ignore-missing-info "$1" 2>/dev/null) | sed -n 's/^shlibs:Depends=//p'
rm -rf "$work"
}
depends=$(shlibdeps "$pkg/usr/bin/uuremote-server")
recommends=""
[ -f "$pkg/usr/bin/uuremote-viewer" ] && recommends=$(shlibdeps "$pkg/usr/bin/uuremote-viewer")
[ -n "$depends" ] || { echo "dpkg-shlibdeps produced no dependencies" >&2; exit 1; }
mkdir -p "$pkg/DEBIAN"
cat > "$pkg/DEBIAN/control" <<CONTROL
Package: uu-remote-linux
Version: $version
Architecture: $arch
Maintainer: VallierDev <[email protected]>
Installed-Size: $size
Depends: $depends, ffmpeg
Recommends: ${recommends:+$recommends, }libwayland-client0, libxkbcommon0
Suggests: libpipewire-0.3-0, libei1, wl-clipboard
Section: net
Priority: optional
Homepage: https://github.com/VallierDev/uu-remote-linux
Description: Unofficial native Linux host for NetEase UU Remote
Lets the official NetEase UU Remote clients control this Linux desktop
(X11, wlroots Wayland and GNOME/KDE Wayland through runtime plugins).
Includes the experimental uuremote-viewer. Not affiliated with NetEase.
CONTROL
cat > "$pkg/DEBIAN/postinst" <<'POSTINST'
#!/bin/sh
set -e
if [ "$1" = configure ]; then
cat <<'MSG'
uu-remote-linux installed. As your desktop user (not root):
uuremote-server login # scan the QR code with the UU Remote app
systemctl --user enable --now uuremote-native.service # start with the graphical session
Optional uinput keyboard/mouse (Wayland): see /usr/share/doc/uu-remote-linux/60-uu-remote-linux-uinput.rules
MSG
fi
POSTINST
chmod 755 "$pkg/DEBIAN/postinst"
mkdir -p "$out"
dpkg-deb --build --root-owner-group "$pkg" "$out/uu-remote-linux_${version}_${arch}.deb"
+17
View File
@@ -0,0 +1,17 @@
# Installed by the uu-remote-linux .deb as a systemd *user* unit; enable it per user:
# systemctl --user enable --now uuremote-native.service
# GNOME and KDE import DISPLAY / WAYLAND_DISPLAY into the user manager when the graphical session
# starts. Desktops that do not (e.g. Xfce) can add a drop-in with Environment=DISPLAY=:0.
[Unit]
Description=UU Remote Linux host (unofficial)
After=graphical-session.target
PartOf=graphical-session.target
[Service]
Environment=RUST_LOG=info
ExecStart=/usr/bin/uuremote-server
Restart=always
RestartSec=5
[Install]
WantedBy=graphical-session.target
+10
View File
@@ -251,6 +251,16 @@ impl UUAuthClient {
Ok((status, value))
}
/// Signed JSON POST to another API host (the signature covers the path only).
pub async fn post_json_url(&self, base: &str, path: &str, body: &serde_json::Value) -> Result<(u16, serde_json::Value), String> {
let body_str = serde_json::to_string(body).map_err(|e| e.to_string())?;
let resp = self.http.post(format!("{base}{path}"))
.headers(self.build_headers("POST", path, &body_str)).body(body_str)
.send().await.map_err(|e| format!("HTTP post {path} failed: {}", transport_error(&e)))?;
let status = resp.status().as_u16();
Ok((status, resp.json().await.unwrap_or(serde_json::Value::Null)))
}
/// Guest APIs use requestPlain for empty requests; sign the actual empty body.
/// Errors intentionally exclude response text and URL (both can contain secrets).
pub async fn assist_post(&self, path: &str, body: Option<&serde_json::Value>) -> Result<(u16, serde_json::Value), String> {
+50 -10
View File
@@ -45,8 +45,8 @@ pub struct VideoSettings {
pub fps: u32,
pub codec: VideoCodec,
pub quality: u64,
/// Viewer max_custom_bitrate (only used for QUALITY_CUSTOM): Mbit/s, or kbit/s above 1000.
pub custom_mbps: u32,
/// Viewer max_custom_bitrate in bits/s (only used for QUALITY_CUSTOM).
pub custom_bps: u32,
/// Scaled stream size (其他分辨率); None streams the native desktop size.
pub output: Option<(u32, u32)>,
/// CHROMA_420 or CHROMA_444 (真彩); 4:4:4 only when the encoder pipeline supports it.
@@ -54,7 +54,7 @@ pub struct VideoSettings {
}
impl Default for VideoSettings {
fn default() -> Self { let (source_id,source_generation)=crate::wayland::selection(); Self { source_id,source_generation, codec: VideoCodec::H264, fps: 60, quality: QUALITY_AUTO, custom_mbps: 0, output: None, chroma: CHROMA_420 } }
fn default() -> Self { let (source_id,source_generation)=crate::wayland::selection(); Self { source_id,source_generation, codec: VideoCodec::H264, fps: 60, quality: QUALITY_AUTO, custom_bps: 0, output: None, chroma: CHROMA_420 } }
}
/// Selectable smaller stream sizes with the desktop's aspect ratio (even dimensions).
@@ -86,8 +86,8 @@ impl VideoSettings {
QUALITY_GENERAL => Some(2_000),
QUALITY_HD => Some(8_000),
QUALITY_BLURAY => Some(20_000),
QUALITY_CUSTOM if self.custom_mbps > 0 =>
Some(if self.custom_mbps > 1_000 { self.custom_mbps } else { self.custom_mbps * 1_000 }.min(100_000)),
QUALITY_CUSTOM if self.custom_bps > 0 =>
Some((self.custom_bps / 1_000).clamp(1, 100_000)),
_ => None,
}
}
@@ -112,6 +112,14 @@ fn fps_from_option(value: u64) -> Option<u64> {
/// Applies a capture-setting RPC to `settings` and returns the RpcResponse payload (Message 22),
/// or None when the RPC is not a capture/fps/quality setting.
/// max_custom_bitrate (field 8) in bit/s: the mobile viewer sends 1_000_000 for 1 Mbps (#67). Values
/// that can only be a different unit stay usable instead of collapsing to a 1 kbit/s cap: below 1000
/// they are Mbit/s, below 200_000 kbit/s (no viewer offers custom rates under 200 kbit/s).
fn custom_bitrate_bps(value: u64) -> u32 {
let bps = if value < 1_000 { value * 1_000_000 } else if value < 200_000 { value * 1_000 } else { value };
bps.min(u64::from(u32::MAX)) as u32
}
pub fn handle_rpc(rpc: &[WireField], settings: &watch::Sender<VideoSettings>, native: (u32, u32)) -> Option<Vec<u8>> {
handle_rpc_with_codecs(rpc, settings, native, true, false)
}
@@ -148,7 +156,7 @@ fn apply_rpc(rpc: &[WireField], settings: &watch::Sender<VideoSettings>, native:
// Field 1 is the viewer's fps option index (1 = 30, 2 = 60, ...); 18 fpsCount is the frame rate.
if let Some(fps) = number(&fields, 18).filter(|v| *v > 0).or_else(|| number(&fields, 1).and_then(fps_from_option)) { next.fps = fps as u32; }
if let Some(quality) = number(&fields, 2).filter(|v| *v > 0) { next.quality = quality; }
if let Some(bitrate) = number(&fields, 8).filter(|v| *v > 0) { next.custom_mbps = bitrate as u32; }
if let Some(bitrate) = number(&fields, 8).filter(|v| *v > 0) { next.custom_bps = custom_bitrate_bps(bitrate); }
// Field 7 chorma_format (sic): 3 = 4:4:4 when 真彩 is on, 1 = 4:2:0. The Sync reports what is encoded.
match number(&fields, 7) {
Some(CHROMA_444) if full_chroma => next.chroma = CHROMA_444,
@@ -237,7 +245,7 @@ pub fn sync_payload(settings: &VideoSettings, native: (u32, u32)) -> Vec<u8> {
put_varint(1, u64::from(settings.fps), &mut out);
put_varint(2, settings.quality, &mut out);
put_varint(3, settings.chroma, &mut out);
if settings.custom_mbps > 0 { put_varint(4, u64::from(settings.custom_mbps), &mut out); }
if settings.custom_bps > 0 { put_varint(4, u64::from(settings.custom_bps), &mut out); }
put_varint(5, u64::from(size.0), &mut out);
put_varint(6, u64::from(size.1), &mut out);
put_varint(9, u64::from(size.0), &mut out);
@@ -284,7 +292,7 @@ mod tests {
put_varint(18, 30, &mut body);
let request = rpc(77, 2, &body);
let response = handle_rpc(&decode_wire(&request).unwrap(), &tx, (1920, 1080)).unwrap();
assert_eq!(*rx.borrow(), VideoSettings { source_id:0,source_generation:0, codec: VideoCodec::H264, fps: 30, quality: QUALITY_GENERAL, custom_mbps: 0, output: None, chroma: CHROMA_420 });
assert_eq!(*rx.borrow(), VideoSettings { source_id:0,source_generation:0, codec: VideoCodec::H264, fps: 30, quality: QUALITY_GENERAL, custom_bps: 0, output: None, chroma: CHROMA_420 });
assert_eq!(rx.borrow().max_kbps(), Some(2_000));
let fields = decode_wire(&response).unwrap();
assert_eq!(message(&fields, 1), Some(&[8u8, 77][..]));
@@ -468,8 +476,40 @@ mod tests {
#[test]
fn auto_quality_keeps_constant_quality_encoding() {
assert_eq!(VideoSettings::default().max_kbps(), None);
assert_eq!(VideoSettings { quality: QUALITY_CUSTOM, custom_mbps: 0, ..Default::default() }.max_kbps(), None);
assert_eq!(VideoSettings { quality: QUALITY_CUSTOM, custom_mbps: 12, ..Default::default() }.max_kbps(), Some(12_000));
assert_eq!(VideoSettings { quality: QUALITY_CUSTOM, custom_bps: 0, ..Default::default() }.max_kbps(), None);
assert_eq!(VideoSettings { quality: QUALITY_CUSTOM, custom_bps: 12_000_000, ..Default::default() }.max_kbps(), Some(12_000));
}
#[test]
fn mobile_custom_bitrate_is_bits_per_second_in_request_and_sync() {
// Mobile viewer sends field 8 = 1_000_000 for 1 Mbps (observed live, 2026-10-20).
for (bps, kbps) in [(1_000_000, 1_000), (30_000_000, 30_000), (500_000, 500), (100_000_000, 100_000), (200_000_000, 100_000)] {
let (tx, rx) = watch::channel(VideoSettings::default());
let mut body = Vec::new();
put_varint(2, QUALITY_CUSTOM, &mut body);
put_varint(8, bps, &mut body);
handle_rpc(&decode_wire(&rpc(7, 2, &body)).unwrap(), &tx, (1920, 1080)).unwrap();
assert_eq!(rx.borrow().max_kbps(), Some(kbps));
let sync = sync_payload(&rx.borrow(), (1920, 1080));
assert_eq!(number(&decode_wire(&sync).unwrap(), 4), Some(bps));
}
}
#[test]
fn small_custom_bitrates_are_read_as_larger_units() {
assert_eq!(custom_bitrate_bps(20), 20_000_000);
assert_eq!(custom_bitrate_bps(8_000), 8_000_000);
assert_eq!(custom_bitrate_bps(1_000_000), 1_000_000);
}
#[test]
fn oversized_custom_bitrate_does_not_wrap_before_encoder_limit() {
let (tx, rx) = watch::channel(VideoSettings::default());
let mut body = Vec::new();
put_varint(2, QUALITY_CUSTOM, &mut body);
put_varint(8, u64::from(u32::MAX) + 1, &mut body);
handle_rpc(&decode_wire(&rpc(8, 2, &body)).unwrap(), &tx, (1920, 1080)).unwrap();
assert_eq!(rx.borrow().max_kbps(), Some(100_000));
}
#[test]
+165
View File
@@ -0,0 +1,165 @@
//! `uuremote-server doctor`: one report with what an issue needs (session, backend, plugins,
//! input permission, encoders, config and service state), safe to paste publicly. It prints only
//! booleans, names and versions: no account ids, tokens, addresses, MACs or file contents, and the
//! home directory is shown as `~`.
fn redact(text: &str) -> String {
let mut out = text.to_owned();
if let Some(home) = std::env::var_os("HOME").and_then(|h| h.into_string().ok()).filter(|h| h.len() > 1) { out = out.replace(&home, "~"); }
if let Ok(user) = std::env::var("USER") { if user.len() > 2 { out = out.replace(&user, "<user>"); } }
out
}
fn env_state(name: &str) -> String {
match std::env::var(name) { Ok(v) if v.is_empty() => "set (empty)".into(), Ok(_) => "set".into(), Err(_) => "unset".into() }
}
fn line(key: &str, value: impl std::fmt::Display) { println!("{key:<22} {}", redact(&value.to_string())); }
fn glibc() -> String {
#[cfg(all(target_os = "linux", target_env = "gnu"))]
{
extern "C" { fn gnu_get_libc_version() -> *const libc::c_char; }
return unsafe { std::ffi::CStr::from_ptr(gnu_get_libc_version()) }.to_string_lossy().into_owned();
}
#[allow(unreachable_code)]
"n/a".into()
}
fn writable(path: &str) -> &'static str {
let Ok(c_path) = std::ffi::CString::new(path) else { return "invalid" };
if !std::path::Path::new(path).exists() { "missing" }
else if unsafe { libc::access(c_path.as_ptr(), libc::W_OK) } == 0 { "writable" } else { "no permission" }
}
async fn command_output(program: &str, args: &[&str]) -> Option<String> {
let output = tokio::time::timeout(std::time::Duration::from_secs(5),
tokio::process::Command::new(program).args(args).kill_on_drop(true).output()).await.ok()?.ok()?;
Some(String::from_utf8_lossy(&output.stdout).trim().to_owned())
}
/// Whether the report must say that this session has no screen to capture: neither DISPLAY nor
/// WAYLAND_DISPLAY is set, and the backend is the X11 one that needs a display to open.
fn missing_display(backend: crate::desktop_backend::DesktopBackend, headless: bool,
display: Option<&std::ffi::OsStr>, wayland: Option<&std::ffi::OsStr>) -> bool {
!headless && backend == crate::desktop_backend::DesktopBackend::X11
&& display.is_none() && wayland.is_none()
}
pub async fn run() -> Result<(), String> {
use crate::desktop_backend as backend;
use crate::engine_plugin::{load, Engine};
// Info logs (e.g. plugin paths under the home directory) would bypass the redaction below.
log::set_max_level(log::LevelFilter::Warn);
println!("uu-remote-linux doctor (safe to paste: no ids, tokens, addresses or file contents)");
line("version", format!("v{} {}", env!("CARGO_PKG_VERSION"), std::env::consts::ARCH));
line("glibc", glibc());
let os = std::fs::read_to_string("/etc/os-release").ok()
.and_then(|t| t.lines().find_map(|l| l.strip_prefix("PRETTY_NAME=").map(|v| v.trim_matches('"').to_owned())));
line("os", os.unwrap_or_else(|| "unknown".into()));
let features: Vec<&str> = [("wayland", cfg!(feature = "wayland")), ("portal", cfg!(feature = "portal")),
("engine-plugins", cfg!(feature = "engine-plugins")), ("inproc-av", cfg!(feature = "inproc-av"))]
.into_iter().filter(|(_, on)| *on).map(|(name, _)| name).collect();
line("build features", if features.is_empty() { "default (X11 only)".to_owned() } else { features.join(", ") });
println!("-- session");
line("XDG_SESSION_TYPE", std::env::var("XDG_SESSION_TYPE").unwrap_or_else(|_| "unset".into()));
line("XDG_CURRENT_DESKTOP", std::env::var("XDG_CURRENT_DESKTOP").unwrap_or_else(|_| "unset".into()));
line("DISPLAY", env_state("DISPLAY"));
line("WAYLAND_DISPLAY", env_state("WAYLAND_DISPLAY"));
line("wayland running", backend::wayland_session_running());
line("UU_DESKTOP_BACKEND", std::env::var("UU_DESKTOP_BACKEND").unwrap_or_else(|_| "auto".into()));
let selected = backend::detect();
line("selected backend", match &selected { Ok(b) if backend::headless() => format!("none (headless, {b:?} unused)"), Ok(b) => format!("{b:?}"), Err(e) => format!("error: {e}") });
if selected.as_ref().is_ok_and(|b| *b == backend::DesktopBackend::X11) && backend::wayland_session_running() && !backend::headless() {
println!(" ! X11 backend inside a Wayland session: the picture will be black");
}
// A session without any display cannot capture a screen; say so instead of naming a backend.
if let Ok(selected) = &selected {
if missing_display(*selected, backend::headless(), std::env::var_os("DISPLAY").as_deref(), std::env::var_os("WAYLAND_DISPLAY").as_deref()) {
println!(" ! DISPLAY and WAYLAND_DISPLAY are unset: the X11 engine will only try :0 and :1; without an X server there, no screen can be captured");
println!(" terminal, file transfer and port mapping still work; UU_DESKTOP_BACKEND=none marks the host as headless");
}
}
if cfg!(feature = "engine-plugins") {
for engine in [Engine::Wayland, Engine::Portal] {
line(engine.file(), match load(engine) { Ok(()) => "loaded".to_owned(), Err(e) => e });
}
}
println!("-- input");
line("/dev/uinput", writable("/dev/uinput"));
line("UU_INPUT_BACKEND", std::env::var("UU_INPUT_BACKEND").unwrap_or_else(|_| "auto".into()));
println!("-- video");
let encoder = crate::video::Encoder::requested();
line("encoder", format!("{encoder:?} (UU_VIDEO_ENCODER={})", std::env::var("UU_VIDEO_ENCODER").unwrap_or_else(|_| "auto".into())));
line("default codec", format!("{:?}", crate::capture_setting::preferred_codec(true, true)));
let mut ffmpeg = crate::video::ffmpeg_command();
ffmpeg.args(["-hide_banner", "-encoders"]).kill_on_drop(true);
match tokio::time::timeout(std::time::Duration::from_secs(5), ffmpeg.output()).await {
Ok(Ok(output)) => {
let text = String::from_utf8_lossy(&output.stdout);
let found: Vec<&str> = ["libx264", "libx265", "h264_nvenc", "hevc_nvenc", "h264_vaapi", "hevc_vaapi"].into_iter()
.filter(|name| text.split_whitespace().any(|word| word == *name)).collect();
line("ffmpeg encoders", if found.is_empty() { "none of libx264/libx265/nvenc/vaapi".to_owned() } else { found.join(", ") });
}
_ => line("ffmpeg encoders", "ffmpeg not runnable (install ffmpeg or set ffmpeg_root)"),
}
let mut version = crate::video::ffmpeg_command();
version.arg("-version").kill_on_drop(true);
if let Ok(Ok(output)) = tokio::time::timeout(std::time::Duration::from_secs(5), version.output()).await {
line("ffmpeg version", String::from_utf8_lossy(&output.stdout).lines().next().unwrap_or("").split_whitespace().nth(2).unwrap_or("unknown"));
}
line("nvidia driver", std::path::Path::new("/proc/driver/nvidia/version").exists());
line("render node", writable(&std::env::var("UU_VAAPI_DEVICE").unwrap_or_else(|_| "/dev/dri/renderD128".into())));
println!("-- audio");
for tool in ["pactl", "pw-cli"] {
line(tool, command_output("sh", &["-c", &format!("command -v {tool} >/dev/null && echo found || echo missing")]).await.unwrap_or_else(|| "unknown".into()));
}
println!("-- account and service");
let path = crate::config::path();
line("config", path.display());
match std::fs::metadata(&path) {
Ok(meta) => {
use std::os::unix::fs::PermissionsExt;
line("config mode", format!("{:o}", meta.permissions().mode() & 0o777));
// Presence only: never read values out of the file.
let fields: Option<serde_json::Value> = std::fs::read(&path).ok().and_then(|b| serde_json::from_slice(&b).ok());
let has = |key: &str| fields.as_ref().and_then(|v| v.get(key)).is_some_and(|v| !v.is_null() && v.as_str() != Some(""));
line("signed in", has("token") && has("user_id"));
line("device registered", has("device_id"));
}
Err(_) => line("config mode", "missing (run `uuremote-server login`)"),
}
line("service", command_output("systemctl", &["--user", "is-active", "uuremote-native.service"]).await.unwrap_or_else(|| "systemctl unavailable".into()));
let running = command_output("pgrep", &["-c", "-x", "uuremote-server"]).await.filter(|n| !n.is_empty()).unwrap_or_else(|| "unknown".into());
line("uuremote-server procs", format!("{running} (including this one; more than 2 means duplicates)"));
Ok(())
}
#[cfg(test)]
mod tests {
#[test]
fn redaction_hides_home_and_user() {
let home = std::env::var("HOME").unwrap_or_default();
if home.len() > 1 { assert_eq!(super::redact(&format!("{home}/.config/x")), "~/.config/x"); }
assert_eq!(super::env_state("UU_DOCTOR_TEST_SURELY_UNSET"), "unset");
}
#[test]
fn a_session_without_any_display_is_reported() {
use crate::desktop_backend::DesktopBackend;
let display = std::ffi::OsStr::new(":0");
let wayland = std::ffi::OsStr::new("wayland-1");
// No DISPLAY and no WAYLAND_DISPLAY: nothing can be captured.
assert!(super::missing_display(DesktopBackend::X11, false, None, None));
// One of them present: the backend has a screen to open.
assert!(!super::missing_display(DesktopBackend::X11, false, Some(display), None));
assert!(!super::missing_display(DesktopBackend::X11, false, None, Some(wayland)));
// Another backend, or a headless host: not this warning.
assert!(!super::missing_display(DesktopBackend::Wayland, false, None, None));
assert!(!super::missing_display(DesktopBackend::X11, true, None, None));
}
}
+20 -3
View File
@@ -268,6 +268,7 @@ pub async fn prepare_device() -> Result<(Value, Credentials), String> {
pub(crate) async fn flow(ui: &LoginUi) -> Result<String, String> {
let (mut cfg, creds) = prepare_device().await?;
let client = UUAuthClient::new(creds.clone());
let mut instant_expiries = 0u32;
loop {
let (status, resp) = client.post_json("/api/v1/qrcode/gen/login", &json!({})).await?;
@@ -293,11 +294,14 @@ pub(crate) async fn flow(ui: &LoginUi) -> Result<String, String> {
// 1 waiting, 2 scanned, 4 after the phone confirmed); the server answers when it changes.
let mut login_status = 1i64;
let mut expired = false;
let generated = std::time::Instant::now();
for _ in 0..150 {
let query = json!({"token": ticket, "qrcode_jump_url": url, "login_status": login_status});
let asked = std::time::Instant::now();
let (status, resp) = match client.post_json("/api/v1/qrcode/login/status", &query).await {
Ok(r) => r,
Err(_) => continue, // long-poll timeout: ask again
// Long-poll timeout: ask again, but never spin on transport errors (#68).
Err(_) => { if asked.elapsed() < Duration::from_secs(1) { tokio::time::sleep(Duration::from_secs(2)).await; } continue; }
};
// Code 1190 (HTTP 400, "二维码已失效"): the QR expired; generate a new one.
if resp.get("code").and_then(|c| c.as_i64()) == Some(QR_EXPIRED) {
@@ -305,7 +309,12 @@ pub(crate) async fn flow(ui: &LoginUi) -> Result<String, String> {
expired = true; break;
}
let st = data("qrcode status", status, &resp)?.get("status").and_then(|v| v.as_i64()).unwrap_or(login_status);
if st == login_status { continue; }
if st == login_status {
// The server normally holds this request; an immediate unchanged answer must not
// turn into a tight loop of dozens of requests per second (#68).
if asked.elapsed() < Duration::from_secs(1) { tokio::time::sleep(Duration::from_secs(2)).await; }
continue;
}
login_status = st;
match st {
2 => {
@@ -343,7 +352,15 @@ pub(crate) async fn flow(ui: &LoginUi) -> Result<String, String> {
}
}
println!("{}", if expired { "QR code expired; generating a new one" } else { "QR code timed out; generating a new one" });
tokio::time::sleep(Duration::from_secs(1)).await; // never spin if the server keeps refusing
// A QR rejected within seconds of being generated, again and again, was seen when the cloud
// flagged this device identity (#68): back off and say how to recover.
if expired && generated.elapsed() < Duration::from_secs(10) { instant_expiries += 1; } else { instant_expiries = 0; }
if instant_expiries == 3 {
eprintln!("The QR code keeps expiring immediately. If this persists, the cloud may reject this device identity: \
back up and remove ~/.config/uuremote/config.json, then run `uuremote-server login` again to register a new device.");
ui.status("二维码反复立即失效:可备份并删除 ~/.config/uuremote/config.json 后重新登录(会注册新设备)", Tone::Error);
}
tokio::time::sleep(Duration::from_secs(1u64 << instant_expiries.min(5))).await; // never spin if the server keeps refusing
}
}
+60 -3
View File
@@ -2,6 +2,8 @@
//! Zero-Wine, Zero-Python, Single-Binary, 5 Native Tools Integrated
mod engine_plugin;
mod doctor;
mod wol;
mod desktop_backend;
mod desktop_session;
mod desktop_power;
@@ -141,6 +143,35 @@ fn write_host_pid() {
let _ = write!(f, "{}", std::process::id());
}
}
/// Why `unit` is not (going to be) running, from `systemctl --user show`; None while it is active or starting.
fn unit_not_running(unit: &str, settled: bool) -> Option<String> {
let output = std::process::Command::new("systemctl").args(["--user", "show", unit, "-p", "ActiveState,SubState,ConditionResult"]).output().ok()?;
let text = String::from_utf8_lossy(&output.stdout);
let value = |key: &str| text.lines().find_map(|l| l.strip_prefix(key).and_then(|v| v.strip_prefix('='))).unwrap_or("").to_owned();
unit_state_problem(unit, &value("ActiveState"), &value("SubState"), &value("ConditionResult"), settled)
}
fn unit_state_problem(unit: &str, active: &str, sub: &str, condition: &str, settled: bool) -> Option<String> {
let hint = format!("see `systemctl --user status {unit}` and `journalctl --user -u {unit}`");
if condition == "no" { return Some(format!("{unit} was skipped: a Condition in the unit is not met (e.g. ConditionEnvironment outside the graphical session); {hint}")); }
if active == "failed" { return Some(format!("{unit} failed to start; {hint}")); }
if sub == "auto-restart" { return Some(format!("{unit} keeps exiting and being restarted; {hint}")); }
if settled && active == "inactive" { return Some(format!("{unit} is not running; {hint}")); }
None
}
#[cfg(test)]
mod show_unit_tests {
#[test]
fn skipped_crashing_and_failed_units_are_reported() {
let p = |a, s, c, settled| super::unit_state_problem("u.service", a, s, c, settled);
assert!(p("inactive", "dead", "no", false).unwrap().contains("skipped"));
assert!(p("activating", "auto-restart", "yes", false).unwrap().contains("restarted"));
assert!(p("failed", "failed", "yes", false).unwrap().contains("failed"));
assert!(p("inactive", "dead", "yes", false).is_none());
assert!(p("inactive", "dead", "yes", true).unwrap().contains("not running"));
assert!(p("active", "running", "yes", true).is_none());
assert!(p("activating", "start", "yes", true).is_none());
}
}
/// `uuremote-server show` (desktop launcher): open the running host's window, or start the host in the
/// foreground with its window when none runs (e.g. no systemd unit installed yet).
fn show_running_host() -> Result<(), Box<dyn std::error::Error>> {
@@ -160,7 +191,10 @@ fn show_running_host() -> Result<(), Box<dyn std::error::Error>> {
.stdout(std::process::Stdio::null()).stderr(std::process::Stdio::null()).status().is_ok_and(|s| s.success());
if installed && std::process::Command::new("systemctl").args(["--user", "start", &unit]).status().is_ok_and(|s| s.success()) {
let before = std::fs::metadata(host_pid_path()).and_then(|m| m.modified()).ok();
for _ in 0..60 {
for attempt in 0..60 {
// `systemctl start` also returns 0 when the unit is skipped by a Condition or keeps
// crashing under Restart=; report that instead of waiting 30 s for a pid (#62).
if let Some(reason) = unit_not_running(&unit, attempt >= 2) { return Err(reason.into()); }
std::thread::sleep(std::time::Duration::from_millis(500));
let fresh = std::fs::metadata(host_pid_path()).and_then(|m| m.modified()).ok().is_some_and(|t| Some(t) != before);
let pid = std::fs::read_to_string(host_pid_path()).ok().and_then(|s| s.trim().parse::<i32>().ok());
@@ -169,7 +203,7 @@ fn show_running_host() -> Result<(), Box<dyn std::error::Error>> {
if unsafe { libc::kill(pid, libc::SIGUSR1) } == 0 { return Ok(()); }
}
}
return Err("the UU remote host service started but did not open its window".into());
return Err(format!("{unit} is running but did not open its window within 30 s; check `journalctl --user -u {unit}`").into());
}
use std::os::unix::process::CommandExt;
Err(Box::new(std::process::Command::new("/proc/self/exe").env("UU_SHOW_WINDOW", "1").exec()))
@@ -191,7 +225,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
.filter_module("uuremote_server", log::LevelFilter::Info).init();
} else { env_logger::Builder::from_env(env_logger::Env::default().default_filter_or("info")).init(); }
// An unknown argument must never fall through to starting a second full host server.
const SUBCOMMANDS: [&str; 14] = ["show", "assist", "desktop-input-probe", "virtual-audio-probe", "login", "unlock-check", "desktop-probe", "desktop-video-probe", "desktop-audio-probe", "wayland-capture",
const SUBCOMMANDS: [&str; 15] = ["doctor", "show", "assist", "desktop-input-probe", "virtual-audio-probe", "login", "unlock-check", "desktop-probe", "desktop-video-probe", "desktop-audio-probe", "wayland-capture",
"wayland-input-probe", "wayland-text-probe", "clipboard-acceptance", "portal-acceptance"];
if let Some(arg) = std::env::args().nth(1).filter(|a| !SUBCOMMANDS.contains(&a.as_str())) {
let usage = format!("usage: uuremote-server [{}]\n (no argument: run the host)", SUBCOMMANDS.join(" | "));
@@ -357,6 +391,9 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
if std::env::args().nth(1).as_deref() == Some("wayland-text-probe") {
return wayland::text_probe().map_err(|e|e.into());
}
if std::env::args().nth(1).as_deref() == Some("doctor") {
return doctor::run().await.map_err(|e| e.into());
}
if std::env::args().nth(1).as_deref() == Some("wayland-capture") {
return wayland::capture_stdout().map_err(|e| e.into());
}
@@ -645,6 +682,11 @@ async fn serve(mut capture: Arc<ScreenCapture>, input: Arc<InputInjector>, shutd
}
SignalingEvent::Connected => {
log::info!("Signaling handshake established.");
static WOL_REPORTED: std::sync::atomic::AtomicBool = std::sync::atomic::AtomicBool::new(false);
if wol::enabled() && assist.as_ref().is_none_or(|s| s.is_account()) && !WOL_REPORTED.swap(true, std::sync::atomic::Ordering::AcqRel) {
let client = auth.clone();
tokio::spawn(async move { wol::report(&client).await; });
}
}
SignalingEvent::RoomInfoAck(_) => { log::info!("RoomInfo acknowledged by NetEase server"); }
SignalingEvent::DeviceInfoChanged(val) => {
@@ -654,6 +696,21 @@ async fn serve(mut capture: Arc<ScreenCapture>, input: Arc<InputInjector>, shutd
log::debug!("Assist bmsg_push shape: type={:?} keys={:?} data_keys={:?}",
val.get("type").and_then(serde_json::Value::as_str), keys(Some(&val)), keys(val.get("data")));
}
if val.get("type").and_then(serde_json::Value::as_str) == Some("wake_on_lan") {
// Key names only: the target carries a MAC and LAN address.
let data = val.get("data").unwrap_or(&val);
log::info!("wake_on_lan push received: keys={:?} target_keys={:?} helper_enabled={}",
data.as_object().map(|o| o.keys().cloned().collect::<Vec<_>>()).unwrap_or_default(),
data.get("target_device").and_then(|t| t.as_object()).map(|o| o.keys().cloned().collect::<Vec<_>>()).unwrap_or_default(),
wol::enabled());
if wol::enabled() {
match wol::handle_push(data) {
Ok(sent) => log::info!("WOL helper: magic packet sent ({sent} datagrams)"),
Err(error) => log::warn!("WOL helper: {error}"),
}
}
continue;
}
if val.get("type").and_then(serde_json::Value::as_str) == Some("get_control_mode") {
if let Some(s) = assist.as_mut() {
match s.control_mode(val.get("data").unwrap_or(&serde_json::Value::Null)).await {
+123
View File
@@ -0,0 +1,123 @@
//! Experimental Wake-on-LAN helper (`UU_WOL_HELPER=1`, off by default).
//!
//! The official Windows host (GameViewerServer: LoginManager::reportLanInfo, PushMessageHandler::wakeOnLan,
//! wake_on_lan.cpp host::send_wol) reports its LAN address to `api-ipv4…/api/v1/device/wake_on_lan/info`
//! after sign-in (logged as "mac / ip / subnet_mask", response carries `turn_on_wol`), and on a
//! `wake_on_lan` cloud push with a `target_device` {mac, ip, subnet_mask} it sends a magic packet to that
//! subnet's broadcast address, waking another PC of the account on the same LAN. The exact request and
//! push field names come from the official log strings only; nothing here is verified end to end yet.
//! Addresses are sent to NetEase only when the helper is enabled and are never logged.
use std::net::{Ipv4Addr, SocketAddrV4, UdpSocket};
pub fn enabled() -> bool { std::env::var("UU_WOL_HELPER").is_ok_and(|v| v == "1") }
/// `aa:bb:cc:dd:ee:ff` / `aa-bb-…` / `aabbcc…` → 6 bytes.
pub fn parse_mac(text: &str) -> Option<[u8; 6]> {
let hex: String = text.chars().filter(|c| c.is_ascii_hexdigit()).collect();
if hex.len() != 12 || text.chars().any(|c| !(c.is_ascii_hexdigit() || matches!(c, ':' | '-' | '.'))) { return None; }
let mut mac = [0u8; 6];
for (i, byte) in mac.iter_mut().enumerate() { *byte = u8::from_str_radix(&hex[i * 2..i * 2 + 2], 16).ok()?; }
(mac != [0; 6] && mac != [0xff; 6]).then_some(mac)
}
/// Six 0xFF bytes followed by the MAC sixteen times.
pub fn magic_packet(mac: [u8; 6]) -> Vec<u8> {
let mut packet = vec![0xff; 6];
for _ in 0..16 { packet.extend_from_slice(&mac); }
packet
}
/// Directed broadcast of `ip`/`mask`, or None when either is missing or invalid.
pub fn subnet_broadcast(ip: &str, mask: &str) -> Option<Ipv4Addr> {
let (ip, mask): (Ipv4Addr, Ipv4Addr) = (ip.parse().ok()?, mask.parse().ok()?);
let mask = u32::from(mask);
if mask == 0 || mask.leading_ones() + mask.trailing_zeros() != 32 { return None; }
Some(Ipv4Addr::from(u32::from(ip) | !mask))
}
/// Handles a `wake_on_lan` push payload; returns how many datagrams were sent.
pub fn handle_push(data: &serde_json::Value) -> Result<usize, String> {
let target = data.get("target_device").or_else(|| data.get("data").and_then(|d| d.get("target_device")))
.ok_or("wake_on_lan push without target_device")?;
let text = |key: &str| target.get(key).and_then(serde_json::Value::as_str).unwrap_or("");
let mac = parse_mac(text("mac")).ok_or("wake_on_lan target has no valid mac")?;
let packet = magic_packet(mac);
let socket = UdpSocket::bind("0.0.0.0:0").map_err(|e| format!("WOL socket: {}", e.kind()))?;
socket.set_broadcast(true).map_err(|e| format!("WOL broadcast: {}", e.kind()))?;
let mut targets = vec![Ipv4Addr::BROADCAST];
if let Some(directed) = subnet_broadcast(text("ip"), text("subnet_mask")) { targets.insert(0, directed); }
let mut sent = 0;
for address in targets { for port in [9, 7] {
if socket.send_to(&packet, SocketAddrV4::new(address, port)).is_ok() { sent += 1; }
} }
if sent == 0 { return Err("WOL packet could not be sent".into()); }
Ok(sent)
}
/// This host's LAN identity on the default IPv4 route: (mac, ip, subnet mask).
#[cfg(target_os = "linux")]
pub fn lan_info() -> Option<(String, String, String)> {
let routes = std::fs::read_to_string("/proc/net/route").ok()?;
let iface = routes.lines().skip(1).map(|l| l.split_whitespace().collect::<Vec<_>>())
.find(|f| f.len() > 2 && f[1] == "00000000")?.first()?.to_string();
let mac = std::fs::read_to_string(format!("/sys/class/net/{iface}/address")).ok()?.trim().to_owned();
parse_mac(&mac)?;
let mut addrs: *mut libc::ifaddrs = std::ptr::null_mut();
if unsafe { libc::getifaddrs(&mut addrs) } != 0 { return None; }
let mut result = None;
let mut cursor = addrs;
while !cursor.is_null() {
let entry = unsafe { &*cursor };
cursor = entry.ifa_next;
if entry.ifa_addr.is_null() || entry.ifa_netmask.is_null() { continue; }
let name = unsafe { std::ffi::CStr::from_ptr(entry.ifa_name) }.to_string_lossy();
if name != iface.as_str() || i32::from(unsafe { (*entry.ifa_addr).sa_family }) != libc::AF_INET { continue; }
let v4 = |p: *mut libc::sockaddr| Ipv4Addr::from(u32::from_be(unsafe { (*(p as *const libc::sockaddr_in)).sin_addr.s_addr }));
result = Some((mac.clone(), v4(entry.ifa_addr).to_string(), v4(entry.ifa_netmask).to_string()));
break;
}
unsafe { libc::freeifaddrs(addrs) };
result
}
#[cfg(not(target_os = "linux"))]
pub fn lan_info() -> Option<(String, String, String)> { None }
/// Report this host's LAN identity like the official host after sign-in.
pub async fn report(auth: &crate::auth::UUAuthClient) {
let Some((mac, ip, subnet_mask)) = lan_info() else { log::warn!("WOL helper: no IPv4 default-route interface"); return; };
let body = serde_json::json!({ "mac": mac, "ip": ip, "subnet_mask": subnet_mask });
match auth.post_json_url("https://api-ipv4.nrd.nie.163.com", "/api/v1/device/wake_on_lan/info", &body).await {
Ok((status, value)) => log::info!("WOL helper: LAN info reported: status={status} code={:?} turn_on_wol={:?}",
value.get("code").and_then(serde_json::Value::as_i64),
value.get("data").and_then(|d| d.get("turn_on_wol")).or_else(|| value.get("turn_on_wol"))),
Err(error) => log::warn!("WOL helper: LAN info report failed: {error}"),
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn mac_parsing_and_packet() {
assert_eq!(parse_mac("AA:bb:cc:dd:ee:01"), Some([0xaa, 0xbb, 0xcc, 0xdd, 0xee, 1]));
assert_eq!(parse_mac("aa-bb-cc-dd-ee-01"), parse_mac("aabbccddee01"));
assert!(parse_mac("aa:bb:cc").is_none() && parse_mac("zz:bb:cc:dd:ee:01").is_none() && parse_mac("00:00:00:00:00:00").is_none());
let packet = magic_packet([1, 2, 3, 4, 5, 6]);
assert_eq!(packet.len(), 102);
assert_eq!(&packet[..6], &[0xff; 6]);
assert_eq!(&packet[96..], &[1, 2, 3, 4, 5, 6]);
}
#[test]
fn directed_broadcast() {
assert_eq!(subnet_broadcast("192.168.2.29", "255.255.255.0"), Some(Ipv4Addr::new(192, 168, 2, 255)));
assert_eq!(subnet_broadcast("10.1.2.3", "255.255.0.0"), Some(Ipv4Addr::new(10, 1, 255, 255)));
assert_eq!(subnet_broadcast("10.1.2.3", "255.0.255.0"), None);
assert_eq!(subnet_broadcast("", "255.255.255.0"), None);
}
#[test]
fn push_without_target_is_rejected() {
assert!(handle_push(&serde_json::json!({})).is_err());
assert!(handle_push(&serde_json::json!({"target_device": {"mac": "nope"}})).is_err());
}
}