Skip to content

feat(deskflow): ThinFloe as a Deskflow server, with clipboard and media keys - #41

Merged
oetiker merged 35 commits into
mainfrom
deskflow-server
Nov 22, 2026
Merged

oetiker merged 35 commits into
mainfrom
deskflow-server

Conversation

@oetiker

@oetiker oetiker commented Nov 22, 2026

Copy link
Copy Markdown
Member

ThinFloe becomes a Deskflow server: its keyboard and mouse drive other computers that run the stock Deskflow client (also Barrier and Input Leap releases that send a TLS client certificate).

Step 1: server core

  • Daemon thinfloe-menu --deskflow, supervised by the menu. It listens on 24800 with mutual TLS and fingerprint pinning (ECDSA P-256 identity in ~/.config/thinfloe/deskflow/, which a fresh install does not copy).
  • Pairing at the machine: in Settings → Screen a device shows as pending, and the user attaches it beside a monitor or rejects it.
  • Edge capture with edge resistance (off/low/medium/high). It uses a layer-shell strip, a pointer lock and an exclusive keyboard, and needs no root. Ctrl+Alt+Shift+Escape, the keep-alive and a 2 s watchdog always release the capture.

Step 2: text clipboard

  • Text is bridged both ways through ext_data_control_v1 (the wlr variant is the fallback), on a Wayland connection of its own. The cap is 1 MiB, and only UTF-8 text is carried.
  • DSOP CLPS/CLSZ options are sent per device. Settings → Screen has a "Share the clipboard" switch for each device.
  • A copy that the bridge does not carry (an image, a file, a text over 1 MiB) empties the attached computers' clipboard, so they never get an older text.

Step 3: media keys follow the pointer

  • labwc patch 0007: a keyboard-shortcuts inhibitor on a focused layer surface blocks every keybinding, also the allowWhenInhibited ones. Inhibitors on views (ThinLinc grab, OxuLnk) behave as before.
  • The capture strip holds such an inhibitor while captured. Volume and brightness keys go to the device. The microphone mute key stays on ThinFloe (thinfloe-menu --osd-key mic-mute, only when the volume-key switch is on).

Tests

  • cargo test: 1451 passed. clippy and fmt are clean.
  • make test-runtime: 107 ok, 0 FAIL. This includes interop cases with the real deskflow-core 1.26 client for pairing, capture, release, the clipboard in both directions, the clipboard switch, the media keys and mic-mute.
  • make test on the rebased head: 19 of 19 suites passed, the image size check included.

Not yet done: the owner's hardware check (a Mac or Windows client, a full-screen ThinLinc session, a German layout on both sides, the 1 px edge strip) is planned on the release.

Design: docs/superpowers/specs/2026-11-21-deskflow-server-design.md. Notes: docs/notes/deskflow.md.

🤖 Generated with Claude Code

oetiker and others added 30 commits November 22, 2026 02:42
ThinFloe's keyboard and mouse drive other computers on the desk that run
the stock Deskflow client: pairing by fingerprint in Settings -> Screen,
edge capture with edge resistance through a layer-shell strip and a
pointer lock, text clipboard, and media keys that follow the pointer
(labwc patch 0007). Built in three steps.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
thinfloe-menu --deskflow is the new process of the Deskflow server. This
first step is its Wayland side (deskflow/capture.rs): 1 px overlay
layer-shell strips along output edges, the oneshot pointer lock, the
relative pointer and the keyboard, as one stream of CapEvents.

begin_capture asks for the lock before it sets keyboard interactivity
exclusive: labwc 0.9.3 activates a lock on a non-view surface only when
the keyboard focus moves (seat_focus), so the lock has to exist first.
Input during a capture is held back until the compositor sends locked.
end_capture destroys the lock and reports Unlocked itself, since the
compositor sends nothing for a lock the client destroyed. The relative
pointer lives with the wl_pointer, as edge resistance needs motion on the
strip before a capture.

--deskflow --probe-capture <output> <side> is the test hook; it names keys
through libxkbcommon (xkbcommon-dl, already in Cargo.lock) because wtype
sends its own key codes (x is 1, not KEY_X 45) in a keymap of its own.
The new runtime case runs it over a fullscreen X11 window that holds a
keyboard grab, as ThinLinc does: the strip gets locked and the x, the X
window does not; after Escape the X window gets y and is active again.
This is the gate of the spec's Risk 1; it passes without a labwc patch.
x11-probe.py gains --fullscreen for --keys.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
The menu derives generated/deskflow (mode 0600) from the new [deskflow]
table, and a broken config.toml is rebuilt from it, so pairings survive.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
The Deskflow server's own identity: a self-signed ECDSA P-256
certificate (CN "ThinFloe <hostname>", ten years) and its PKCS#8 key in
one PEM file, made on first use (directory 0700, file 0600, written
through crate::atomic). A file without a certificate and its matching
key is an error and stays untouched, since a new identity would make
every paired client distrust ThinFloe; the check also means the server
config built from a loaded identity cannot fail.

fingerprint() is SHA-256 over the DER certificate as Deskflow writes it
(v2:sha256:<hex>); colon_hex() and random_art() give the two forms
Deskflow's dialogs show. random_art() ports the algorithm of
generateFingerprintArt in Deskflow's SecureUtils.cpp (commit 80221f0).

tls::server_config() offers TLS 1.2 and 1.3 with ring and requires a
client certificate; its verifier skips the chain check (Deskflow's
certificates are self-signed, trust is the fingerprint) but still
verifies the handshake signature with the presented certificate.

New crates rustls, rcgen, ring and rustls-pki-types, default features
off, ring only.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
`thinfloe-menu --deskflow` without arguments is now the Deskflow
daemon: one poll loop (at most 250 ms) over the signal self-pipe
(SIGTERM, SIGHUP through sigaction), the command socket, the TCP
listener, the Wayland capture connection and every client connection.
A connection is a non-blocking TcpStream under rustls (conn.rs, split
from run.rs by responsibility); at most four connections may be in TLS,
Hello or the verdict, a fifth is closed at once; TLS, Hello and the
HelloBack share 10 s. Plaintext is taken 64 KiB at a time and its frames
are cut before the next read; a framer error closes the connection.
pair::judge on the peer fingerprint gives the verdict in the same loop
pass as the name; a second connection of a connected device gets EBSY;
a rejected pair gets EUNK at once and stays "rejected" in the state
file. Reload (SIGHUP or "reload") re-reads generated/deskflow, closes
connections of forgotten devices, re-binds on a port change and ends
with 0 when listen is false. A watchdog thread exits 70 when the loop
has not turned for 2 s; a closed Wayland connection ends the daemon
with 0. An exclusive flock on <state>.lock keeps a second daemon from
taking the command socket ("another deskflow daemon runs", exit 1, the
state file untouched). An absent generated/deskflow is listen = false
(exit 0); a bad file, a damaged identity ("identity: ...", never
regenerated) or a port in use ("port 24800 in use") is the error head
of the state file and exit 1. The daemon sets PR_SET_PDEATHSIG SIGTERM.

After a refusal (EUNK, EBSY, EICV) the connection stays open up to 2 s
for the client to read it and hang up, as Deskflow's own server does
(it waits 5 s): a Deskflow 1.26 client that sees the end of the stream
together with EUNK drops the message, logs "disconnected from server"
and retries as after a network failure (seen in the interop run before
the linger was added).

The certificate's validity is now fixed, 2000-01-01 to 2099-12-31: a
first boot with a wrong clock must not shorten a certificate that is
kept for good.

Facts the spec marked "verify", from the interop run against the stock
deskflow-core 1.26.0 (Ubuntu 26.04 universe) and its source (v1.26.0
and master 80221f0):
- ECDSA P-256 server key accepted: yes (the client connects and logs
  the server's fingerprint; no RSA fallback, ruling R2 not used).
- Validity dates: not checked by the client. Client-side TLS sets
  SSL_VERIFY_PEER with a cert verify callback that returns 1
  (SecureSocket::initContext, verifyIgnoreCertCallback); trust is the
  fingerprint in tls/trusted-servers only.
- The client retries after EUNK: yes, 1 s later (ClientApp::retryTime),
  and the retry after the attach connects.
- Hello framed with the 4-byte length: yes (the client parses it and
  answers).
- deskflow-core 1.26 has no connection flags: everything comes from the
  INI file given with -s (client/remoteHost, core/port,
  core/computerName, security/tlsEnabled); its tls dir is that file's
  directory plus /tls (deskflow.pem, trusted-servers). Its console shows
  only NOTE and IPC lines, whatever log/level says.

Tests: run.rs over loopback with a rustls client (pending, attach and
reload, CIAK/CROP/DSOP after DINF, EBSY, fp-changed, reject, SIGTERM),
the handshake limit and an oversized frame, switching off, second
instance, absent and bad config, damaged identity, port in use; ident
pins the fixed dates. test-labwc-runtime.sh gains the interop case
run_deskflow_pairing_case; test/runtime/Dockerfile installs deskflow.
The tls test client moved to tls::testclient for reuse.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Port Deskflow's keysym to KeyID rules and the KeyTypes.h values (commit
80221f0), add the Xkb wrapper for keymap, state and modifiers, and move the
probe's keymap code into the shared module.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
…ound

switching_off_ends_the_daemon_and_frees_the_port failed now and then
under the full suite: the test helper start() sent the daemon's port to
the test before the daemon thread had bound its command socket, and the
test's first cmd::send(Reload) then hit no socket (NoServer) and the
unwrap panicked. A 300 ms sleep before cmd::bind in the thread makes it
fail every time. The port now goes out after the bind.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
A push past a monitor edge with a connected device attached captures
pointer and keyboard (pointer lock + exclusive keyboard on the strip) and
forwards motion (DMMV through the edge tracker), buttons (DMDN/DMUP with
the ids of Deskflow's MouseTypes.h), the wheel (DMWM, v120, positive up
and right) and keys (DKDN/DKRP/DKUP, repeat generated from the
compositor's repeat info) to that device. One release path sends DKUP for
every key sent down and DMUP for every button, then COUT, ends the
capture and logs "thinfloe-deskflow: released (<reason>)". It runs on the
way back over the edge, Ctrl+Alt+Shift+Escape (not forwarded), the
connection closing, Unlocked, keyboard focus lost, the strip's output
gone, no Locked within 500 ms, and SIGTERM (then CBYE to every client).

The captured-state logic lives in deskflow/forward.rs (on_cap_event,
tick, release) so it is testable without Wayland. Also: the input
hold-back before Locked is a pure passes(); keys pressed before the lock
are never sent up; key_id falls back to the level-0 keysym; non-finite
motion is dropped; strips per device with edge-busy and offline in the
state file; at most 64 accepts per loop turn; judge, refuse_busy and
set_verdict take the turn's now.

Runtime: the Deskflow client runs on labwc's own Xwayland, and the case
works around two artefacts of that, found with the client's DEBUG1 log
and a RECORD of its XTest requests: Xwayland drops the first XTest
button press and release, and an X keymap change (the first XTest key,
the end of every wtype call) makes the client forget the keys it holds
(KeyState::updateKeyMap clears m_serverKeys), so a key up is never
faked. x11-probe.py --record now also prints KEYUP, BUTTONUP and the
XTest requests.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
The Task 10 work changed the 'osd | bright' media-key case to switch off
HEADLESS-1 by mistake; the forwarding case was the one that needed
HEADLESS-1. The check's own label says "with HEADLESS-2 switched off",
and the markgone pixel m1=1265,49 lies on the output that stays on.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
The menu starts 'thinfloe-menu --deskflow' while [deskflow] listen is on
(deskflow_sup::Supervisor): own process group, output to the session
log, restarts after an exit with a back-off of 1, 2, 4 ... 60 s (a run of
60 s resets it), SIGTERM and SIGKILL after 1 s when the switch goes off,
SIGHUP for a reload, and before every exit of the menu (after the save
of 0, 10 and 11) SIGTERM with a wait of at most 1 s. last_failure() holds
the error head the failed run wrote, else its status, for the Screen
band. A daemon's end wakes the loop through a waiter thread (waitid
WNOWAIT); due starts and kills set a WaitUntil from about_to_wait.

PR_SET_PDEATHSIG follows the forking thread, so the daemon is spawned
only from the event loop's main thread, and the daemon now checks after
the prctl that its parent (TF_DESKFLOW_PARENT, else the parent at start)
is still the one that started it. The daemon starts with SIGHUP blocked
and unblocks it once its handler is set: a reload sent right after a
start had ended it with the default action.

Runtime case deskflow_lifecycle: listener up, gone after Log out and
Restart, gone after a SIGKILL of the menu, restarted after a SIGKILL of
the daemon.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
When try_wait failed (the child reaped elsewhere, ECHILD), tick logged
the error and returned None, keeping the Running entry forever: no
start again, and a later SIGTERM or SIGKILL could reach a process that
had since been given the same pid. The child now counts as ended: it is
dropped, the error is the last failure, and a start again is scheduled
as after any failure (at once when the menu had asked it to end).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Settings -> Screen gets a Deskflow band under the monitors: the switch,
"This computer: <addr>:<port>" with ThinFloe's fingerprint (random art
and colon hex) and the note to check it on the other computer, the edge
resistance select, each pending device with Attach... and Reject (and the
fp-changed warning), and "Deskflow stopped: <reason>" from the
supervisor's last failure.

Attached devices are drawn as outlined boxes beside their monitor at the
monitors' scale (16:9 before they report a size), with a status dot
(connected, active, offline). Selecting one shows Position (the free
edges of the active arrangement, as "Right of DP-1") and Forget; an edge
that is not free says so. Devices whose monitor is off or missing are
listed in the band, so they can still be moved or forgotten.

deskflowtab.rs holds the logic (apply, free_edges, inactive, the state
file reader); deskflow_ui.rs draws. A Save request becomes
store.update(Table::Deskflow) (generated/deskflow first) and then
deskflow_changed() (SIGHUP and want(listen)) and a home save; Reject goes
to the command socket. The state file is re-read on an mtime change by
the watcher thread, at the battery file's cadence.

Clipboard on/off (spec) is not offered: the brief's copy for a selected
device names Position and Forget only.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
…stale stop reason

A device attached Right of DP-1 was still drawn there after DP-2 was
docked right of DP-1. Its box lay inside DP-2's box, which painted over
it and took its clicks, and the band listed only the selected device and
devices whose monitor was off. So Position, Forget and "This edge is not
free in the current arrangement." could not be reached. Now an inactive
device whose box overlaps a monitor is not drawn, and the band lists
every device the arrangement does not show at its edge
(deskflowtab::band_devices).

"Deskflow stopped: <reason>" showed while the daemon ran again, because
the supervisor keeps its last failure until want() or a long run. The
line now shows only while the daemon does not run
(deskflowtab::stopped_line).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
A fresh install's home copy now leaves out ~/.config/thinfloe/deskflow, the
Deskflow private key, like the SSH host keys.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
A client CALV was answered with a CALV, and the stock client echoes every
CALV it gets (ServerProxy.cpp "echo keep alives"), so a connected device
and ThinFloe traded keep-alives at network speed for as long as it stayed
connected. The Deskflow server only notes a client CALV; so does ThinFloe
now, keeping its own keep-alive every 3 s.

Edge resistance fired on any motion once the sum reached the threshold,
so with "off" (threshold 0) the pointer entering the strip, or any inward
or sideways motion on it, began a capture: after coming back from a
device the pointer still sits on the strip and was sent straight back.
Only a push outward fires now; the Enter no longer pushes.

Smaller fixes from the final review:
- Without a keymap the escape chord is decided by the evdev codes of
  Ctrl, Alt, Shift and Escape, so the way back never depends on it.
- A modifier pressed while a key repeats no longer cancels the repeat;
  only a key that repeats takes it over, as the X server does.
- A strip the compositor closes counts as missing and is made again a
  second later, instead of only when the wanted strips change.
- proto.rs loses its stale allow(dead_code); clean_name's doc comment
  sits on clean_name again.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
… edge on re-attach

A state file left from an earlier run listed pending devices while the
daemon did not run, and Reject then failed with "Deskflow does not run.".
Pending rows now show only while the daemon runs.

The Position control of a device attaching again under a new fingerprint
left out the edge its old entry holds, so it could not keep its own
place. The control now leaves the device's own name out of the taken
edges for pending and attached devices alike.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
…tity dates

From the final review:
- Known limits name what the user notices of the 1 px strip (clicks
  and a full-screen session's last row at an attached edge go to the
  strip); the spec no longer claims resistance keeps hot corners and
  auto-hide taskbars usable there.
- The Capture notes claimed a keyboard-shortcuts inhibitor that is not
  built (step 3); they now say so, and that only an outward push starts
  a capture.
- The notes name the first releases that send a client certificate:
  Deskflow 1.20.0 (deskflow#7931), Barrier 2.4.0 (commit 229abab),
  Input Leap 3.0.0 (its first release, containing that commit), from the
  release notes and the GitHub history.
- Spec and plan give the identity's validity as 2000-01-01 to
  2099-12-31, as the code does.
- CHANGES says the switch is off by default, in three shorter sentences.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
App::redraw applied out.textures_delta to the CPU canvas with apply_set and
apply_free (both take a reference) but never cleared it, on the backdrop
pass, the settling early return and the normal frame. epaint's Drop for
TexturesDelta debug_asserts that the list is empty, so a debug build
panicked on the first frame ("Dropped TexturesDelta with 5 unapplied
deltas"); release builds compile the check out. The OSD and brand.rs
already clear it. Present on main before this branch.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
The Session needs the text clipboard on the wire before the daemon can
share it: a codec for the marshalled form and DCLP transfers, an
assembler that drops oversize transfers instead of erroring, and the
CLPS/CLSZ options in the first DSOP. Id 1 transfers are assembled and
dropped so a valid stream never closes the connection.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
The daemon needs the text clipboard on a Wayland connection of its own,
so a clipboard fault never touches the capture. clip.rs speaks
ext_data_control_v1 (zwlr_data_control_v1 as fallback), reads a foreign
selection through a non-blocking pipe bounded to CLIP_MAX and 2 s, skips
its own source by a private marker mime and serves set_text from the
poll loop. The hidden --deskflow --probe-clip mode and a runtime case
(wl-copy, wl-paste, a 3 MB copy) cover it under headless labwc.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
ClipSync (deskflow/clipsync.rs) is the pure policy: a ThinFloe selection
goes to the device with the pointer and as a grab (CCLP) to every other
device that shares the clipboard; a device's text becomes ThinFloe's
selection and is remembered for the next enter; a device's grab reaches
the others. The device a text came from does not get the same bytes
back, neither when a second ThinFloe client re-offers them nor on its
next enter.

run.rs connects the Wayland bridge at start (a failure is logged and the
daemon runs without clipboard), polls its descriptor and transfer pipes,
takes its transfer deadline into the poll timeout, and drops the bridge on
any of its errors instead of ending the daemon. The device's Clipboard
switch is applied at the verdict (so the DSOP after DINF carries it) and
on every reload. Connections are named by Conn::id, which is stable,
since the conns Vec shifts on removal.

conn.rs raises the rustls send buffer to 2 MiB: at rustls's default of
64 KiB, any clipboard over 64 KiB closed the connection as "the client
does not read".

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Each capture enter sent the whole remembered clipboard again, up to
1 MiB, although the device already held those bytes. A few quick edge
crossings on a slow link queued more than the 2 MiB send buffer, and the
daemon dropped a healthy client as "the client does not read"; the
pointer also waited behind each transfer.

ClipSync now keeps the devices that hold ThinFloe's text (the one it
came from and those it was sent to) and sends only to the others. A new
ThinFloe text, a device's grab (a Deskflow client empties its clipboard
on a CCLP) and a device's text reset the list. This set replaces the
single source mark of the echo guard.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
The daemon honours a device's clipboard flag on reload, but the menu had
no way to change it. A switch in the attached device's detail writes it
through the same Save request as Position and Forget, so the daemon is
reloaded the usual way.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Three runtime cases drive the stock deskflow-core 1.26 client against the
daemon: ThinFloe's text reaches the device on entry, a copy on the device
reaches ThinFloe when the pointer comes back, and a device with
clipboard = false keeps its own text.

The client runs on an Xvfb of its own (xvfb and xclip join the test
image): on labwc's Xwayland the compositor bridges the X and the Wayland
clipboard itself, so the cases would pass without Deskflow. The 1.26 X11
client notices a local copy only through SelectionClear, which needs it to
own the clipboard first, so the copy-from-device case runs after the
copy-to-device case. Each case was checked to fail with the switch set the
other way.

The notes get a Clipboard section and the known limits (text only, no
primary selection, 1 MiB, stale text between a device's grab and its data,
a holder kept across a switch off and on); CHANGES gets the entry.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
oetiker and others added 5 commits November 22, 2026 02:42
While the Deskflow capture strip holds the keyboard, the volume and
brightness keys must reach the attached device. The media key bindings
carry allowWhenInhibited="yes" (0006) so they pass a ThinLinc grab or an
OxuLnk inhibitor, and 0004 ignored an inhibitor on a layer surface, so
they kept acting on ThinFloe during a capture, also over a fullscreen
X11 window with a keyboard grab.

Patch 0007 activates an inhibitor on a layer surface and, while the
seat's keyboard focus is a layer surface that has one (looked up in the
wlroots manager's list, so no count to keep in step), runs no keybinding
at all, allowWhenInhibited ones included. View inhibitors are unchanged.

The daemon binds zwp_keyboard_shortcuts_inhibit_manager_v1 (optional: on
a compositor without it the capture still works) and puts an inhibitor
on the strip in begin_capture, right after taking the keyboard
exclusively; end_capture destroys it, and every strip removal goes
through end_capture.

The runtime case drives the capture probe with THINFLOE_VOLUME_KEYS=on
and TF_OSD_KEY_CMD at a recorder, with and without an X11 grab: the key
reaches the probe and the recorder stays silent while captured, and the
binding runs again after Escape and after the probe exits.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Task 6 put a shortcuts inhibitor on the capture strip, so labwc runs no
media key binding while a device has the keyboard and the volume and
brightness keys reach the device. The microphone mute key has no Deskflow
key id, so it would do nothing at all: forward.rs now keeps its press and
release from the device and turns the release (of a press seen during the
capture, as labwc's onRelease binding) into Action::LocalMicMute. The
daemon then runs `thinfloe-menu --osd-key mic-mute` (TF_OSD_KEY_CMD as
the composer takes it) in its own process group, without waiting, and
reaps it each turn of the loop.

The daemon reads only generated/deskflow, so that file gains
mic_mute_local, the Keyboard tab's volume key switch; it is not part of
[deskflow]. Table::Keyboard renders generated/deskflow too, and the menu
sends the daemon SIGHUP after a saved keyboard choice. A file without the
key reads as false.

The capture also logs once when the compositor has no shortcuts inhibit
manager, as the media keys then still act on ThinFloe.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Table::Keyboard renders generated/deskflow too (mic_mute_local), and that
render validates [deskflow]. The store keeps a hand-edited [deskflow]
that does not validate, so every keyboard save failed with "Could not
save the keyboard settings: Deskflow: ...". For a table other than
[deskflow] a failing render of generated/deskflow now leaves the file as
it is and logs it; an update of [deskflow] itself still refuses.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
When ThinFloe's selection became an image, a file list or a text over
the 1 MiB cap, no event reached ClipSync: it kept the previous text and
sent it on the next entry into a device. A password copied before and
"overwritten" by an image could so reach a laptop. The bridge now
reports such a selection (no text mime, empty, over the cap, a failed
or expired read) as ClipEvent::Cleared; ClipSync forgets the text and
sends CCLP to every sharing device, the active one too. A selection
that ends because its source exited still keeps the text.

A device whose Clipboard switch changes is forgotten as a holder, so
turning sharing on again sends it ThinFloe's text on the next entry
(the documented known limit is gone).

The daemon runs at most 4 OSD key commands at once, so a hung
thinfloe-menu --osd-key cannot pile up children. press_osd_key is a
free function, which makes mic_mute_local = false testable without
Wayland; the process-group test now keeps the child alive and asserts
pgid == pid instead of accepting -1.

The probe prints "cleared"; the runtime clip case asserts it once
after the 3 MB copy. CLAUDE.md: rewrap the labwc constraint.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
@oetiker
oetiker merged commit 1135560 into main Nov 22, 2026
7 checks passed
@oetiker
oetiker deleted the deskflow-server branch November 22, 2026 02:22
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

None yet

Projects

None yet

Development

Successfully merging this pull request may close these issues.

1 participant