souveraine/surfaces/quickshell/services/SessiondBridge.qml

// Shell side of the souveraine-sessiond handoff protocol.
//
// sessiond takes ext-session-lock before the shell exists; this bridge is
// how the shell (a) announces itself and takes the lock over, (b) keeps the
// heartbeat connection open so sessiond can retake the lock the moment the
// shell dies, and (c) confirms the compositor-acked lock (locked_ack).
//
// The session is never unlocked during the handoff: sessiond abandons its
// lock (connection drop) and misc:allow_session_lock_restore lets our
// WlSessionLock inherit the locked session. See
// souveraine/src/sessiond/protocol.rs — that file is the contract.
//
// No sessiond on the socket (laptop, or bring-up) = everything no-ops and
// the legacy launchOnStartup path decides alone.
pragma Singleton
import QtQuick
import Quickshell
import Quickshell.Io
import qs

Singleton {
    id: root

    // Registered = shell_ready was answered ok on the CURRENT connection.
    property bool registered: false
    // sessiond held the session lock when we registered; we owe it a lock
    // and a locked_ack.
    property bool oweLock: false
    property bool ackSent: false
    property var pendingReady: null // callback awaiting the shell_ready response

    function load() {}

    // Announce the shell. cb(mustLock) fires exactly once: mustLock true
    // means sessiond was holding and the session IS locked — the shell must
    // raise its own lock surface immediately.
    function shellReady(cb) {
        if (!sock.connected) {
            cb(false);
            return;
        }
        if (root.pendingReady) {
            // Only one handshake in flight; late duplicate answers false.
            cb(false);
            return;
        }
        root.pendingReady = cb;
        readyTimeout.restart();
        sock.write(JSON.stringify({ op: "shell_ready" }) + "\n");
        sock.flush();
    }

    function sendLockedAck() {
        if (!sock.connected || !root.registered || root.ackSent) return;
        root.ackSent = true;
        sock.write(JSON.stringify({ op: "locked_ack" }) + "\n");
        sock.flush();
        console.log("[sessiond-bridge] locked_ack sent");
    }

    Timer {
        id: readyTimeout
        interval: 3000
        repeat: false
        onTriggered: {
            if (root.pendingReady) {
                console.log("[sessiond-bridge] shell_ready timed out — proceeding without sessiond");
                const cb = root.pendingReady;
                root.pendingReady = null;
                cb(false);
            }
        }
    }

    // Reconnect: sessiond may restart (upgrade) or start late. While
    // connected this timer is idle; the Socket does not retry by itself.
    Timer {
        id: reconnect
        interval: 5000
        repeat: true
        running: !sock.connected
        onTriggered: sock.connected = true
    }

    Socket {
        id: sock
        path: Quickshell.env("XDG_RUNTIME_DIR") + "/souveraine/sessiond.sock"
        connected: true

        onSocketConnected: {
            console.log("[sessiond-bridge] connected");
            // A fresh connection is never registered yet. If we were
            // registered before (sessiond restarted underneath us),
            // re-register right away so the heartbeat resumes.
            const wasRegistered = root.registered;
            root.registered = false;
            root.ackSent = false;
            if (wasRegistered) {
                root.shellReady(function(mustLock) {
                    if (mustLock) {
                        // sessiond locked while we were disconnected (it
                        // treats our EOF as shell death). Mirror it.
                        GlobalStates.screenLocked = true;
                    }
                });
            }
        }
        onSocketDisconnected: {
            console.log("[sessiond-bridge] disconnected");
            root.registered = false;
            root.pendingReady = null;
        }

        parser: SplitParser {
            splitMarker: "\n"
            onRead: message => {
                let reply;
                try {
                    reply = JSON.parse(message);
                } catch (e) {
                    console.log("[sessiond-bridge] unparseable reply: " + message);
                    return;
                }
                if (root.pendingReady) {
                    // The only request we await a response for.
                    const cb = root.pendingReady;
                    root.pendingReady = null;
                    readyTimeout.stop();
                    if (reply.ok) {
                        root.registered = true;
                        root.oweLock = reply.must_lock === true;
                        console.log("[sessiond-bridge] registered, must_lock=" + root.oweLock);
                        cb(root.oweLock);
                    } else {
                        console.log("[sessiond-bridge] shell_ready refused: " + reply.reason);
                        cb(false);
                    }
                }
            }
        }
    }

    // The compositor acknowledged OUR lock surface — tell sessiond the
    // handoff is complete. Gated on secure, not the request, per doctrine.
    Connections {
        target: GlobalStates
        function onScreenLockSecureChanged() {
            if (GlobalStates.screenLockSecure && root.oweLock && !root.ackSent) {
                root.sendLockedAck();
            }
        }
    }
}