#!/bin/sh
 # Launch cce-server with cce-client
 # Usage: startcce [--logging] [--verbose] [--debug]
 #
 #   --logging  announce the log paths. The compositor's stderr goes to
 #              $CCE_RUN/cce.log regardless; this flag no longer raises the
 #              log level. The session entry in /usr/share/wayland-sessions
 #              passes it, and it used to mean `--log-level debug`: every
 #              transaction, key press and xwm property became a formatted
 #              line on the compositor's main thread, tens of MB per session,
 #              for a log that is only read when something goes wrong. Start
 #              with --verbose when it is.
 #   --verbose  compositor at `--log-level debug` (what --logging did before
 #              2026-09-11).
 #   --debug    --verbose plus WAYLAND_DEBUG=1 on the client.
 
 LOGGING=false
 VERBOSE=false
 DEBUG=false
 for arg in "$@"; do
     case "$arg" in
         --logging) LOGGING=true ;;
         --verbose) VERBOSE=true ;;
         --debug) DEBUG=true ;;
     esac
 done
 
 export XDG_RUNTIME_DIR=/run/user/$(id -u)
 export XDG_CURRENT_DESKTOP=cce
 export XDG_SESSION_TYPE=wayland
 export PATH="$HOME/.local/bin:$PATH"
 export XCURSOR_THEME="cce"
 # No XCURSOR_SIZE. Wayland toolkits already default to 24 logical pixels (sctk,
 # GTK and Chromium all do), and the two worlds want DIFFERENT numbers: under
 # `xwayland_hidpi` X11 is a physical-pixel world, so an X11 cursor has to be
 # 24*scale, which the compositor publishes as the `Xcursor.size` X resource
 # when Xwayland comes up (server.rs). XCURSOR_SIZE beats that resource in both
 # libXcursor and libxcb-cursor, so exporting it here made every X11 app ask for
 # a 24-pixel cursor and get one drawn at half size.
 export XCURSOR_PATH="${XDG_DATA_HOME:-$HOME/.local/share}/icons:$HOME/.icons:/usr/share/icons"
 # KEEP THIS. Removed on 2026-09-11 (cce-compositor@43a9108) on the theory
 # that the Intel cursor plane would work now that the session is pinned to
 # card1 and wlroots falls back to software on failure; the very next login
 # had NO visible cursor at all — the plane accepted the image and showed
 # nothing, so there was no failure to fall back from. A software cursor
 # costs a scene composite per pointer motion; an invisible one costs the
 # session. Do not remove again without verifying on the real display.
 export WLR_NO_HARDWARE_CURSORS=1
 export WLR_DRM_DEVICES=/dev/dri/card1
 # The session renders on the Intel GPU, so Vulkan is pinned to the Intel ICD.
 # This is not only a compositor concern: an app that also loads the NVIDIA
 # Vulkan ICD (libGLX_nvidia.so.0) and then asks NVIDIA OpenCL about its
 # Mesa GL context segfaults inside the NVIDIA driver — Houdini did, six
 # seconds after launch, every time it came from the launcher. It is
 # imported into the systemd user manager below for that reason: apps spawned
 # by cce-cloud (a user service) inherit the manager's environment, not this
 # script's, and without the import they ran under a different GPU setup than
 # anything the compositor spawned directly.
 export VK_DRIVER_FILES=/usr/share/vulkan/icd.d/intel_icd.json
 # EGL gets the same pin. WLR_DRM_DEVICES keeps the compositor off the NVIDIA
 # KMS node, but glvnd's libEGL still probes every installed vendor when a
 # display is created, and libEGL_nvidia opens /dev/nvidiactl and /dev/nvidia0
 # to answer — so the compositor held the discrete GPU out of its runtime-D3
 # sleep for the whole session (2026-09-28 audit: ~3 W on battery, never
 # suspended). Pinning glvnd to Mesa's vendor file means the NVIDIA EGL is
 # never loaded. Nothing is lost: every external port is wired to the
 # discrete GPU and WLR_DRM_DEVICES already excludes them, and GLX (Xwayland
 # apps, __GLX_VENDOR_LIBRARY_NAME) and Vulkan (CCE_VK_DEVICE lifts the pin
 # per process) are separate mechanisms. Imported below like VK_DRIVER_FILES,
 # for the same reason: a launcher-spawned EGL client would otherwise wake
 # the GPU too.
 export __EGL_VENDOR_LIBRARY_FILENAMES=/usr/share/glvnd/egl_vendor.d/50_mesa.json
 # Mesa's rusticl exposes NO OpenCL devices unless enabled per driver — without
 # this the session has zero OpenCL platforms from Mesa, and every OpenCL
 # consumer that wants the Intel GPU fails quietly: the designer's
 # kernel-generated geometry (the default project's sphere) simply never
 # appears. (The NVIDIA ICD is live too and serves the discrete GPU.)
 export RUSTICL_ENABLE=iris
 
 # The compositor binary this session runs, resolved once so the server launch
 # and the generated client launcher cannot disagree. Absolute rather than
 # leaning on the PATH set above: this is the one process a session cannot
 # recover from failing to find. $HOME is guaranteed — cce-display-manager sets
 # it explicitly when it execs this script, and the config read below already
 # depends on it.
 CCE_BIN="$HOME/.local/bin/cce"
 
 # Session runtime files: per-user, not /tmp. In /tmp these were a single path
 # every user of the machine raced for — whoever logged in first owned
 # /tmp/cce.log, and /tmp's sticky bit then denied everyone else, so a second
 # user's session logged nothing (or failed to write its launcher at all).
 # XDG_RUNTIME_DIR is /run/user/UID, 0700, exported just above. It is cleared
 # at logout, which costs nothing here: the compositor log is truncated on
 # every login anyway, and a start failure is tailed to the console below
 # while the directory still exists.
 CCE_RUN="$XDG_RUNTIME_DIR/cce"
 if ! mkdir -p "$CCE_RUN" 2>/dev/null; then
     # Gate on the failure itself, not on a guess about when it can happen:
     # pam_systemd normally creates /run/user/UID before this script runs, but
     # if it is missing or unwritable the launcher below cannot be written and
     # the session comes up with no client at all. /tmp is worse but it works.
     echo "startcce: $CCE_RUN unusable, falling back to /tmp" >&2
     CCE_RUN=/tmp
 fi
 CCE_LOG="$CCE_RUN/cce.log"
 CCE_CLIENT_LOG="$CCE_RUN/cce-client.log"
 CCE_LAUNCH="$CCE_RUN/launch.sh"
 
 # The DE's default terminal (config.kdl `default_terminal`, set from the
 # settings app) becomes $TERMINAL for the whole session, so non-cce tools
 # that honor the convention agree with the launcher. A crude KDL read, but
 # the key is a single top-level string node.
 TERMINAL_CFG=$(sed -n 's/^[[:space:]]*default_terminal[[:space:]]*"\([^"]*\)".*/\1/p' "$HOME/.config/cce/config.kdl" 2>/dev/null | head -n 1)
 if [ -n "$TERMINAL_CFG" ] && command -v "$TERMINAL_CFG" >/dev/null 2>&1; then
     export TERMINAL="$TERMINAL_CFG"
 fi
 
 # Kill any stale processes to ensure DRM master and sockets are released.
 # killall matches on comm (argv[0]'s basename), which reflects how a process
 # was started, not which binary it is: started through the `cce` symlink comm
 # is "cce", but a compositor left over from `make run` / `cargo run --bin
 # cce-fx` has comm "cce-fx" and would survive this sweep still holding DRM
 # master. So name both. ("cce-client" sat here for years and never matched
 # anything: there is no such binary — the client is the subcommand
 # `cce client`, whose comm is also "cce", already covered.)
 killall -q cce cce-fx 2>/dev/null
 # pkill -9 -f antigravity 2>/dev/null
 # pkill -9 -f language_server 2>/dev/null
 
 
 # Create the cce-client launch script
 DEBUG_FLAG=""
 if [ "$DEBUG" = true ]; then
     DEBUG_FLAG="WAYLAND_DEBUG=1 "
 fi
 
 # Unquoted delimiter on purpose: $DEBUG_FLAG, $TERMINAL, $CCE_BIN and
 # $CCE_CLIENT_LOG expand HERE, so the generated script carries concrete values
 # and depends on none of this environment. Quoting LAUNCH_EOF would ship the
 # literal '$CCE_BIN' and the client would never start.
 cat > "$CCE_LAUNCH" << LAUNCH_EOF
 #!/bin/sh
 systemctl --user import-environment DISPLAY WAYLAND_DISPLAY XDG_CURRENT_DESKTOP XDG_SESSION_TYPE XDG_SESSION_ID XDG_RUNTIME_DIR GNOME_KEYRING_CONTROL SSH_AUTH_SOCK RUSTICL_ENABLE VK_DRIVER_FILES __EGL_VENDOR_LIBRARY_FILENAMES${TERMINAL:+ TERMINAL}
 systemctl --user start cce-session.target
 ${DEBUG_FLAG}exec "$CCE_BIN" client 2>"$CCE_CLIENT_LOG"
 LAUNCH_EOF
 chmod +x "$CCE_LAUNCH"
 
 LOG_LEVEL_FLAG=""
 if [ "$VERBOSE" = true ] || [ "$DEBUG" = true ]; then
     LOG_LEVEL_FLAG="--log-level debug"
 fi
 if [ "$LOGGING" = true ] || [ "$VERBOSE" = true ] || [ "$DEBUG" = true ]; then
     echo "Starting cce-server with cce..."
     echo "  Logs: $CCE_LOG + $CCE_CLIENT_LOG (compositor level: ${LOG_LEVEL_FLAG:---log-level info})"
     if [ "$DEBUG" = true ]; then
         echo "  Wayland debug logging enabled (WAYLAND_DEBUG=1)"
     fi
 fi
 
 if [ "$DEBUG" = true ]; then
     export WAYLAND_DEBUG=1
 fi
 
 # Clear out any old log file so we only see errors from this run
 > "$CCE_LOG"
 
 # Run CCE in the background so we can check if it exits immediately
 "$CCE_BIN" ${LOG_LEVEL_FLAG} -c "$CCE_LAUNCH" 2>>"$CCE_LOG" &
 CCE_PID=$!
 
 # Wait briefly to verify it launched successfully
 sleep 1.2
 if ! kill -0 $CCE_PID 2>/dev/null; then
     wait $CCE_PID
     EXIT_CODE=$?
     echo ""
     echo "Error: cce failed to start (exited with code $EXIT_CODE)."
     echo "Showing last 15 lines of $CCE_LOG:"
     echo "----------------------------------------"
     tail -n 15 "$CCE_LOG"
     echo "----------------------------------------"
     exit $EXIT_CODE
 fi
 
 # If it runs fine, wait on it to finish
 wait $CCE_PID
 systemctl --user stop cce-session.target