#!/usr/bin/python3 import base64 import ctypes import json import math import os import runpy import select import signal import socket import struct import subprocess import sys import time HERE = os.path.dirname(os.path.realpath(__file__)) COMPAT = runpy.run_path(os.path.join(HERE, "steam-compatibility")) BINDING = "droiddeckCompatChanged" BRIGHTNESS_BINDING = "droiddeckBrightnessChanged" CONTROLS_DIR = "/etc/droiddeck-device-controls" LIBRARY_ART_JS = r""" (() => { if (window.__droiddeckLibraryArt) return "present"; const store = typeof appStore === "object" ? appStore : null; if (typeof store?.BHasCachedLibraryAsset !== "function") return "unavailable"; // The client reports which cached assets exist only after a logon that reaches Steam; before that every app reads as // uncached and the UI asks the CDN, which is blank offline. The native check still runs, so misses are still reported. const native = store.BHasCachedLibraryAsset.bind(store); store.BHasCachedLibraryAsset = (appid, version, type) => native(appid, version, type) || !version; window.__droiddeckLibraryArt = true; return "installed"; })() """ BRIGHTNESS_JS = r""" (() => { if (window.__droiddeckBrightness) return "present"; const display = SteamClient.System?.Display; if (!display?.RegisterForBrightnessChanges || !display?.SetBrightness) return "unavailable"; const self = { expected: null, updating: true, revision: 0, localAt: -Infinity }; // A held stick steps Steam faster than Android's readback returns; those stale readbacks would snap the slider back. const HOLD_MS = 750; // Returns "held" while a readback is being ignored, so the caller retries it after the hold. self.set = value => { if (typeof value !== "number" || !Number.isFinite(value) || value < 0 || value > 1) return true; if (performance.now() - self.localAt < HOLD_MS) return "held"; if (!self.updating && self.expected !== null && Math.abs(value - self.expected) < 0.0001) return true; self.expected = value; self.updating = true; const revision = ++self.revision; setTimeout(() => { if (self.revision === revision) self.updating = false; }, 500); display.SetBrightness(value); return true; }; self.subscription = display.RegisterForBrightnessChanges(state => { const value = state?.flBrightness; if (typeof value !== "number" || !Number.isFinite(value) || value < 0 || value > 1 || self.expected === null) return; if (Math.abs(value - self.expected) < 0.0001) { self.updating = false; return; } if (self.updating) { self.updating = false; return; } self.expected = value; self.localAt = performance.now(); if (typeof window.__BINDING__ === "function") window.__BINDING__(String(value)); }); window.__droiddeckBrightness = self; return "installed"; })() """.replace("__BINDING__", BRIGHTNESS_BINDING) def brightness_request(payload, directory=CONTROLS_DIR): try: value = float(payload) if not math.isfinite(value) or not 0 <= value <= 1: return path = os.path.join(directory, "brightness.request") with open(path + ".tmp", "w") as target: target.write(str(value) + "\n") os.replace(path + ".tmp", path) except (ValueError, TypeError, OSError): return INSTALL_JS = r""" (() => { if (window.__droiddeckCompat) return "present"; const enc = new TextEncoder(), dec = new TextDecoder(); const varint = (value, out) => { let n = BigInt(value); do { let b = Number(n & 0x7fn); n >>= 7n; if (n) b |= 0x80; out.push(b); } while (n); }; const key = (field, wire, out) => varint(field * 8 + wire, out); const str = (field, s, out) => { const b = enc.encode(s); key(field, 2, out); varint(b.length, out); for (const x of b) out.push(x); }; const uint = (field, v, out) => { key(field, 0, out); varint(v, out); }; const fixed64 = (field, v, out) => { key(field, 1, out); let n = BigInt(v); for (let i = 0; i < 8; i++) { out.push(Number(n & 0xffn)); n >>= 8n; } }; const parse = (bytes) => { const fields = {}; let i = 0; const read = () => { let r = 0n, s = 0n, b; do { b = bytes[i++]; r |= BigInt(b & 0x7f) << s; s += 7n; } while (b & 0x80); return r; }; while (i < bytes.length) { const k = Number(read()), field = k >> 3, wire = k & 7; let v; if (wire === 0) v = read(); else if (wire === 1) { v = 0n; for (let j = 0; j < 8; j++) v |= BigInt(bytes[i + j]) << BigInt(8 * j); i += 8; } else if (wire === 2) { const n = Number(read()); v = bytes.subarray(i, i + n); i += n; } else if (wire === 5) { v = bytes.subarray(i, i + 4); i += 4; } else throw new Error("unexpected wire type " + wire); (fields[field] = fields[field] || []).push(v); } return fields; }; const text = (f, n) => f[n] ? dec.decode(f[n][0]) : ""; const self = { seq: 0, pending: new Map(), ws: null, opening: null, changes: 0 }; const frame = (method, body, auth) => { const h = []; fixed64(10, ++self.seq, h); str(12, method, h); if (auth) str(40, auth, h); const out = new Uint8Array(8 + h.length + body.length); const view = new DataView(out.buffer); view.setUint32(0, (0x80000000 | 146) >>> 0, true); view.setUint32(4, h.length, true); out.set(h, 8); out.set(body, 8 + h.length); return [self.seq, out]; }; const onMessage = (event) => { const bytes = new Uint8Array(event.data); const length = new DataView(event.data).getUint32(4, true); const header = parse(bytes.subarray(8, 8 + length)); const target = header[11] ? Number(header[11][0] & 0xffffffffn) : -1; if (self.pending.has(target)) { const done = self.pending.get(target); self.pending.delete(target); const result = header[13] ? Number(header[13][0]) : 2; done(result === 1 ? { ok: true, body: parse(bytes.subarray(8 + length)) } : { ok: false, eresult: result, error: text(header, 14) }); return; } if (text(header, 12).startsWith("CompatManager.NotifyStateChanged")) { self.changes++; if (typeof window.__BINDING__ === "function") window.__BINDING__(String(self.changes)); } }; const send = (method, body, auth) => new Promise((resolve, reject) => { const [id, out] = frame(method, Uint8Array.from(body), auth); const timer = setTimeout(() => { self.pending.delete(id); reject(new Error(method + " timed out")); }, 10000); self.pending.set(id, (r) => { clearTimeout(timer); resolve(r); }); self.ws.send(out); }); const open = async () => { const info = await SteamClient.WebUITransport.GetTransportInfo(); const ws = new WebSocket("ws://127.0.0.1:" + info.portClientdll + "/transportsocket/"); ws.binaryType = "arraybuffer"; await new Promise((resolve, reject) => { ws.onopen = resolve; ws.onerror = () => reject(new Error("the client's transport refused the connection")); }); ws.onmessage = onMessage; ws.onclose = () => { if (self.ws === ws) self.ws = null; for (const done of self.pending.values()) done({ ok: false, eresult: 0, error: "connection closed" }); self.pending.clear(); }; self.ws = ws; const body = []; str(1, info.authKeyClientdll, body); const r = await send("TransportAuth.Authenticate#1", body, info.authKeyClientdll); if (!r.ok) { ws.close(); throw new Error("the client's transport refused authentication (" + r.eresult + ")"); } }; const ready = async () => { if (self.ws && self.ws.readyState === 1) return; if (!self.opening) self.opening = open().finally(() => { self.opening = null; }); await self.opening; }; self.get = async (appid) => { await ready(); const body = []; uint(1, appid, body); const r = await send("CompatManager.GetCompatTools#1", body); if (!r.ok) throw Object.assign(new Error("GetCompatTools " + appid + " failed (" + r.eresult + " " + r.error + ")"), { eresult: r.eresult }); return { selected: text(r.body, 3), fallback: text(r.body, 4), tools: (r.body[1] || []).map((t) => text(parse(t), 1)) }; }; self.set = async (appid, name) => { await ready(); const body = []; uint(1, appid, body); str(2, name, body); const r = await send("CompatManager.SpecifyCompatTool#1", body); if (!r.ok) throw new Error("SpecifyCompatTool " + appid + " " + name + " failed (" + r.eresult + " " + r.error + ")"); return true; }; self.many = async (apps) => { const out = {}; for (const app of apps) { try { out[app] = (await self.get(Number(app))).selected; } catch (e) { if (e.eresult !== 128) throw e; } } return out; }; window.__droiddeckCompat = self; return "installed"; })() """.replace("__BINDING__", BINDING) TOOLS_JS = r""" (() => { if (window.__droiddeckTools) return "present"; const installs = SteamClient.Installs, downloads = SteamClient.Downloads; if (typeof installs?.OpenInstallWizard !== "function" || typeof installs?.RegisterForShowInstallWizard !== "function" || typeof installs?.ContinueInstall !== "function" || typeof downloads?.QueueAppUpdate !== "function") throw new Error("the client's install calls are not ready"); const self = { asked: new Map() }; installs.RegisterForShowInstallWizard((state) => { const app = Number(state?.currentAppID); if (state?.eInstallState === 7 && Date.now() - (self.asked.get(app) || 0) < 120000) { self.asked.delete(app); installs.ContinueInstall(); } }); self.install = (app) => { self.asked.set(app, Date.now()); installs.OpenInstallWizard([app], "0"); return true; }; self.update = (app) => { downloads.QueueAppUpdate(app, "0"); return true; }; window.__droiddeckTools = self; return "installed"; })() """ TOOL_CHECK_SECONDS = 60 TOOL_RETRY_SECONDS = 300 SWITCH_BINDING = "droiddeckSwitchToDesktop" SWITCH_JS = r""" (() => { if (window.__droiddeckSwitch) return "present"; const name = new TextEncoder().encode("SteamOSManager.SwitchToDesktop#"); const send = WebSocket.prototype.send; const asks = (data) => { const bytes = data instanceof ArrayBuffer ? new Uint8Array(data) : ArrayBuffer.isView(data) ? new Uint8Array(data.buffer, data.byteOffset, data.byteLength) : null; if (!bytes) return false; const end = Math.min(bytes.length, 256) - name.length; for (let i = 8; i <= end; i++) { let j = 0; while (j < name.length && bytes[i + j] === name[j]) j++; if (j === name.length) return true; } return false; }; WebSocket.prototype.send = function (data) { if (typeof window.__BINDING__ === "function" && asks(data)) window.__BINDING__(""); return send.call(this, data); }; window.__droiddeckSwitch = true; return "installed"; })() """.replace("__BINDING__", SWITCH_BINDING) SESSION_SELECT = "/usr/bin/steamos-session-select" TOUR_JS = r""" (() => { let key = 140014 * 8; const bytes = []; while (key > 127) { bytes.push((key & 127) | 128); key = Math.floor(key / 128); } bytes.push(key, 0); SteamClient.Settings.SetSetting(btoa(String.fromCharCode(...bytes))); return "off"; })() """ FRAME_LIMIT_JS = r""" (() => { if (window.__droiddeckFrameLimit) return "present"; const settings = window.settingsStore; let service = null; try { // Steam's webpack does not expose its module cache; the gamescope service client is found by // the calls its module makes and loaded by id. let require; window.webpackChunksteamui.push([[Symbol("droiddeck-frame-limit")], {}, r => { require = r; }]); for (const id of Object.keys(require.m || {})) { const source = String(require.m[id]); if (!source.includes("SetBlurParams") || !source.includes("RegisterForNotifyStateChanged")) continue; let exports; try { exports = require(id); } catch (e) { continue; } if (!exports || typeof exports !== "object") continue; service = Object.values(exports).find(value => value && typeof value.GetState === "function" && typeof value.RegisterForNotifyStateChanged === "function" && typeof value.SetBlurParams === "function"); if (service) break; } } catch (e) { service = null; } if (!service || !settings?.clientSettings || typeof SteamClient.Settings?.SetSetting !== "function") return "unavailable"; const self = { timer: null }; const write = value => { const bytes = []; for (let n of [21002 * 8, value]) { while (n > 127) { bytes.push((n & 127) | 128); n = Math.floor(n / 128); } bytes.push(n); } return SteamClient.Settings.SetSetting(btoa(String.fromCharCode(...bytes))); }; self.check = async () => { let rates; try { const reply = await service.GetState({}); if (!reply.BSuccess()) return; rates = reply.Body().toObject().state?.active_display_info?.supported_frame_rates; } catch (e) { return; } if (!Array.isArray(rates) || rates.length === 0) return; const current = settings.clientSettings; if (!current.gamescope_enable_app_target_framerate || rates.includes(current.gamescope_app_target_framerate)) return; try { await write(Math.max(...rates)); } catch (e) { } }; self.schedule = () => { clearTimeout(self.timer); self.timer = setTimeout(self.check, 1500); }; self.subscription = service.RegisterForNotifyStateChanged(self.schedule); self.interval = setInterval(self.schedule, 5000); self.schedule(); window.__droiddeckFrameLimit = self; return "installed"; })() """ WINDOW_BINDING = "droiddeckWindowAction" WINDOW_TARGET = "createflags=18" WINDOW_MOVES = {"nw": 0, "n": 1, "ne": 2, "e": 3, "se": 4, "s": 5, "sw": 6, "w": 7, "move": 8} WINDOW_JS = r""" (() => { if (window.__droiddeckWindow) return "present"; const EDGE = 5, CORNER = 10, THRESHOLD = 3; const CURSORS = { n: "ns-resize", s: "ns-resize", e: "ew-resize", w: "ew-resize", ne: "nesw-resize", sw: "nesw-resize", nw: "nwse-resize", se: "nwse-resize" }; const send = action => window.droiddeckWindowAction(action); const filled = () => innerWidth >= screen.availWidth && innerHeight >= screen.availHeight - 60; const side = e => { if (filled()) return ""; const right = innerWidth - e.clientX, bottom = innerHeight - e.clientY; const near = (a, b) => a < EDGE || (a < CORNER && b < CORNER); const across = Math.min(e.clientX, right), along = Math.min(e.clientY, bottom); const v = near(e.clientY, across) ? "n" : near(bottom, across) ? "s" : ""; const h = near(e.clientX, along) ? "w" : near(right, along) ? "e" : ""; return v + h; }; const dragging = (x, y) => { for (const node of document.elementsFromPoint(x, y)) { const region = getComputedStyle(node).webkitAppRegion; if (region === "drag") return true; if (region === "no-drag") return false; } return [...document.querySelectorAll("*")].some(node => { if (getComputedStyle(node).webkitAppRegion !== "drag") return false; const box = node.getBoundingClientRect(); return x >= box.left && x < box.right && y >= box.top && y < box.bottom; }); }; const style = document.createElement("style"); document.documentElement.append(style); let press = null, shown = ""; addEventListener("pointermove", e => { if (press) { if (Math.hypot(e.clientX - press.x, e.clientY - press.y) >= THRESHOLD) { const hit = dragging(press.x, press.y); press = null; if (hit) send("move"); } return; } const cursor = e.buttons ? shown : side(e); if (cursor !== shown) { shown = cursor; style.textContent = cursor ? `* { cursor: ${CURSORS[cursor]} !important; }` : ""; } }, true); addEventListener("pointerdown", e => { if (e.button !== 0) return; const edge = side(e); if (edge) { e.stopPropagation(); e.preventDefault(); send(edge); } else { press = { x: e.clientX, y: e.clientY }; } }, true); addEventListener("pointerup", () => { press = null; }, true); addEventListener("dblclick", e => { if (dragging(e.clientX, e.clientY) && !side(e)) send("maximize"); }, true); SteamClient.Window.ToggleMaximize = () => send("maximize"); window.__droiddeckWindow = true; return "installed"; })() """ FILE_BINDING = "droiddeckOpenFileDialog" FILE_JS = r""" (() => { const cancelled = () => ({ result: 2, message: "" }); if (window.__droiddeckFiles) { window.__droiddeckFiles.cancelAll(); return "present"; } const self = { next: 0, pending: new Map() }; const open = function (options) { return new Promise((resolve, reject) => { if (typeof window.__BINDING__ !== "function") { reject(cancelled()); return; } const id = ++self.next; self.pending.set(id, { resolve, reject }); try { window.__BINDING__(JSON.stringify({ id, options: options || {} })); } catch (e) { self.pending.delete(id); reject(cancelled()); } }); }; self.done = (id, path) => { const item = self.pending.get(id); if (!item) return false; self.pending.delete(id); if (typeof path === "string" && path) item.resolve(path); else item.reject(cancelled()); return true; }; self.cancelAll = () => { const items = Array.from(self.pending.values()); self.pending.clear(); for (const item of items) item.reject(cancelled()); }; const patch = (w) => { const system = w?.SteamClient?.System; if (system && system.OpenFileDialog !== open) system.OpenFileDialog = open; }; patch(window); if (SteamClient.System.OpenFileDialog !== open) throw new Error("Steam OpenFileDialog could not be redirected"); const popups = window.g_PopupManager; if (popups) { for (const popup of popups.GetPopups?.() || []) patch(popup.window); popups.AddPopupCreatedCallback?.((popup) => patch(popup.window)); } window.__droiddeckFiles = self; return "installed"; })() """.replace("__BINDING__", FILE_BINDING) VR_BINDING = "droiddeckLaunchSteamVr" VR_HELPER = "/usr/local/bin/droiddeck-steamvr" VR_JS = r""" (() => { if (window.__droiddeckSteamVr) return "present"; const apps = SteamClient.Apps; if (!apps || typeof apps.RunGame !== "function") throw new Error("Steam RunGame is not ready"); const run = apps.RunGame; const self = { running: false, pending: new Map(), lastError: null }; const flush = () => { if (!self.running) return; const queued = Array.from(self.pending.values()); self.pending.clear(); for (const item of queued) { clearTimeout(item.timer); run.call(item.receiver, item.id, ...item.args); } }; if (typeof SteamClient.OpenVR?.RegisterForVRModeChange === "function") { self.subscription = SteamClient.OpenVR.RegisterForVRModeChange(running => { self.running = !!running; flush(); }); } const wrapped = function (id, ...args) { const gameid = String(id); if (typeof window.__BINDING__ !== "function") return run.call(this, id, ...args); if (gameid === "250820") { window.__BINDING__(gameid); return; } const overview = window.appStore?.GetAppOverviewByGameID?.(gameid); const vr = overview?.vr_only === true; if (vr && self.subscription && /^[1-9][0-9]{0,19}$/.test(gameid)) { if (self.pending.has(gameid)) return; self.lastError = null; const item = { receiver: this, id, args, timer: null }; item.timer = setTimeout(() => { self.pending.delete(gameid); self.lastError = "SteamVR did not become ready. Start SteamVR from DroidDeck and try the game again."; console.error("DroidDeck: " + self.lastError); }, 600000); self.pending.set(gameid, item); try { window.__BINDING__(gameid); } catch (e) { clearTimeout(item.timer); self.pending.delete(gameid); throw e; } flush(); return; } return run.call(this, id, ...args); }; apps.RunGame = wrapped; if (apps.RunGame !== wrapped) throw new Error("Steam RunGame could not be redirected"); if (typeof SteamClient.OpenVR?.StartVR === "function") { const start = SteamClient.OpenVR.StartVR; SteamClient.OpenVR.StartVR = function (...args) { if (typeof window.__BINDING__ === "function") return window.__BINDING__("250820"); return start.apply(this, args); }; } window.__droiddeckSteamVr = self; return "installed"; })() """.replace("__BINDING__", VR_BINDING) def launch_steamvr(): say("SteamVR library launch: using the DroidDeck ARM64 helper") state = os.path.join(os.environ.get("XDG_RUNTIME_DIR", "/tmp"), "droiddeck-steamvr") try: os.makedirs(state, exist_ok=True) with open(os.path.join(state, "library-launch.log"), "a") as log: return subprocess.Popen([VR_HELPER, "launch"], stdin=subprocess.DEVNULL, stdout=log, stderr=subprocess.STDOUT, start_new_session=True) except OSError as e: say("SteamVR library launch failed: %s" % e) def choose_file(options): import gi gi.require_version("Gdk", "3.0") gi.require_version("Gtk", "3.0") from gi.repository import Gdk, Gtk directory = bool(options.get("bChooseDirectory")) save = bool(options.get("bSaveMode")) and not directory action = (Gtk.FileChooserAction.SELECT_FOLDER if directory else Gtk.FileChooserAction.SAVE if save else Gtk.FileChooserAction.OPEN) dialog = Gtk.FileChooserDialog(title=str(options.get("strTitle") or ""), action=action) dialog.add_buttons("gtk-cancel", Gtk.ResponseType.CANCEL, "gtk-save" if save else "gtk-open", Gtk.ResponseType.ACCEPT) dialog.set_default_response(Gtk.ResponseType.ACCEPT) dialog.set_local_only(True) dialog.set_do_overwrite_confirmation(True) for folder in ("/root/Storage", "/mnt/droiddeck-sd"): if os.path.isdir(folder): try: dialog.add_shortcut_folder(folder) except Exception: pass if not directory: for entry in options.get("rgFilters") or []: patterns = [str(p) for p in entry.get("rFilePatterns") or [] if p] if not patterns: continue chosen = Gtk.FileFilter() chosen.set_name(str(entry.get("strFileTypeName") or ", ".join(patterns))) for pattern in patterns: pattern = "*" if pattern == "*.*" else pattern chosen.add_pattern(pattern) if pattern.lower() != pattern.upper(): chosen.add_pattern(pattern.upper()) dialog.add_filter(chosen) if entry.get("bUseAsDefault"): dialog.set_filter(chosen) initial = str(options.get("strInitialFile") or "").strip('"') if initial: if os.path.isdir(initial): dialog.set_current_folder(initial) elif save: if os.path.isdir(os.path.dirname(initial)): dialog.set_current_folder(os.path.dirname(initial)) dialog.set_current_name(os.path.basename(initial)) elif os.path.exists(initial): dialog.set_filename(initial) elif os.path.isdir(os.path.dirname(initial)): dialog.set_current_folder(os.path.dirname(initial)) screen = Gdk.Screen.get_default() if screen is not None: dialog.set_default_size(screen.get_width(), screen.get_height()) chosen_path = dialog.get_filename() if dialog.run() == Gtk.ResponseType.ACCEPT else None dialog.destroy() return chosen_path class Closed(Exception): pass def say(message): print("droiddeck-steam-compat: %s" % message, flush=True) def called(event, name): return event.get("method") == "Runtime.bindingCalled" and event.get("params", {}).get("name") == name def switch_to_desktop(): say("Switch to Desktop: asking for the desktop") try: subprocess.call([SESSION_SELECT, "plasma"]) except OSError as e: say("Switch to Desktop failed: %s" % e) def connect(port, timeout=5): sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) sock.settimeout(timeout) try: sock.bind(("127.0.0.1", 0)) sock.connect(("127.0.0.1", port)) except OSError: sock.close() raise return sock def http_get(port, path): sock = connect(port) try: sock.sendall(("GET %s HTTP/1.1\r\nHost: 127.0.0.1:%d\r\nConnection: close\r\n\r\n" % (path, port)).encode()) data = b"" length = None while length is None or len(data) < length: chunk = sock.recv(65536) if not chunk: break data += chunk if length is None and b"\r\n\r\n" in data: head, _, rest = data.partition(b"\r\n\r\n") for line in head.split(b"\r\n")[1:]: name, _, value = line.partition(b":") if name.strip().lower() == b"content-length": length = int(value.strip()) if length is None: length = float("inf") data = rest if not head.startswith(b"HTTP/1.1 200"): raise OSError("devtools answered %r" % head[:40]) finally: sock.close() return json.loads(data.decode("utf-8", "replace")) class WebSocket: def __init__(self, port, path): self.sock = connect(port) key = base64.b64encode(os.urandom(16)).decode() self.sock.sendall(("GET %s HTTP/1.1\r\nHost: 127.0.0.1:%d\r\nUpgrade: websocket\r\nConnection: Upgrade\r\n" "Sec-WebSocket-Key: %s\r\nSec-WebSocket-Version: 13\r\n\r\n" % (path, port, key)).encode()) self.buffer = b"" while b"\r\n\r\n" not in self.buffer: self.fill() head, _, self.buffer = self.buffer.partition(b"\r\n\r\n") if not head.startswith(b"HTTP/1.1 101"): raise OSError("devtools refused the websocket: %r" % head[:60]) self.sock.settimeout(None) def fileno(self): return self.sock.fileno() def fill(self): chunk = self.sock.recv(65536) if not chunk: raise Closed("devtools closed the connection") self.buffer += chunk def take(self, n): while len(self.buffer) < n: self.fill() data, self.buffer = self.buffer[:n], self.buffer[n:] return data def send(self, text, opcode=1): payload = text.encode() if isinstance(text, str) else text mask = os.urandom(4) n = len(payload) if n < 126: head = struct.pack("!BB", 0x80 | opcode, 0x80 | n) elif n < 65536: head = struct.pack("!BBH", 0x80 | opcode, 0xFE, n) else: head = struct.pack("!BBQ", 0x80 | opcode, 0xFF, n) self.sock.sendall(head + mask + bytes(b ^ mask[i % 4] for i, b in enumerate(payload))) def pending(self): return len(self.buffer) > 0 def recv(self): message = b"" while True: first, second = self.take(2) n = second & 0x7F if n == 126: n = struct.unpack("!H", self.take(2))[0] elif n == 127: n = struct.unpack("!Q", self.take(8))[0] mask = self.take(4) if second & 0x80 else None payload = self.take(n) if mask: payload = bytes(b ^ mask[i % 4] for i, b in enumerate(payload)) opcode = first & 0x0F if opcode == 8: raise Closed("devtools closed the websocket") if opcode == 9: self.send(payload, 10) continue if opcode == 10: continue message += payload if first & 0x80: return message.decode("utf-8", "replace") def close(self): try: self.sock.close() except OSError: pass class Page: def __init__(self, port, path): self.ws = WebSocket(port, path) self.next_id = 0 self.events = [] def call(self, method, params=None, timeout=30): self.next_id += 1 mine = self.next_id self.ws.send(json.dumps({"id": mine, "method": method, "params": params or {}})) deadline = time.monotonic() + timeout while True: if not self.ws.pending(): left = deadline - time.monotonic() if left <= 0 or not select.select([self.ws], [], [], left)[0]: raise TimeoutError("%s timed out" % method) message = json.loads(self.ws.recv()) if message.get("id") == mine: if "error" in message: raise RuntimeError("%s: %s" % (method, message["error"].get("message"))) return message.get("result", {}) if "method" in message: self.events.append(message) def evaluate(self, expression, timeout=30): result = self.call("Runtime.evaluate", {"expression": expression, "awaitPromise": True, "returnByValue": True}, timeout) if "exceptionDetails" in result: details = result["exceptionDetails"] raise RuntimeError((details.get("exception") or {}).get("description") or details.get("text") or "script failed") return result.get("result", {}).get("value") def tools(self, call): return self.evaluate("%s;\nwindow.__droiddeckTools.%s" % (TOOLS_JS, call)) def compat(self, call): return self.evaluate("%s;\nwindow.__droiddeckCompat.%s" % (INSTALL_JS, call)) def drain(self): while True: if not self.ws.pending() and not select.select([self.ws], [], [], 0)[0]: break message = json.loads(self.ws.recv()) if "method" in message: self.events.append(message) events, self.events = self.events, [] return events def shared_context(port): for target in http_get(port, "/json/list"): if target.get("title") == "SharedJSContext" and target.get("webSocketDebuggerUrl"): path = target["webSocketDebuggerUrl"].split("/", 3)[3] return "/" + path return None class Watcher: MASK = 0x00000008 | 0x00000080 | 0x00000100 | 0x00000200 def __init__(self, files): self.files = files self.fd = -1 self.libc = None wanted = {os.path.dirname(f) for f in files} self.missing = {d for d in wanted if not os.path.isdir(d)} self.watched = set() try: libc = ctypes.CDLL(None, use_errno=True) fd = libc.inotify_init1(os.O_NONBLOCK | os.O_CLOEXEC) dirs = sorted((wanted - self.missing) | {self.existing_parent(d) for d in self.missing} - {""}) if fd >= 0 and dirs and all(libc.inotify_add_watch(fd, d.encode(), self.MASK) >= 0 for d in dirs): self.watched = set(dirs) self.fd = fd self.libc = libc elif fd >= 0: os.close(fd) except (OSError, AttributeError): self.fd = -1 self.stamp = self.snapshot() @staticmethod def existing_parent(path): while path and not os.path.isdir(path): parent = os.path.dirname(path) if parent == path: return "" path = parent return path def watch_new_dirs(self): appeared = False progressed = True while progressed: progressed = False for d in sorted(self.missing): parent = d if os.path.isdir(d) else self.existing_parent(d) if not parent or parent in self.watched: continue if self.libc.inotify_add_watch(self.fd, parent.encode(), self.MASK) >= 0: self.watched.add(parent) progressed = True appeared = appeared or parent == d for d in [d for d in self.missing if d in self.watched]: self.missing.discard(d) return appeared def snapshot(self): stamp = [] for f in self.files: for p in (f, os.path.dirname(f)): try: stamp.append(os.stat(p).st_mtime_ns) except OSError: stamp.append(0) return stamp def fileno(self): return self.fd def changed(self): if self.fd < 0: stamp = self.snapshot() moved, self.stamp = stamp != self.stamp, stamp return moved names = set() try: while True: data = os.read(self.fd, 65536) if not data: break at = 0 while at + 16 <= len(data): _, _, _, size = struct.unpack_from("iIII", data, at) names.add(data[at + 16:at + 16 + size].split(b"\0", 1)[0].decode("utf-8", "replace")) at += 16 + size except BlockingIOError: pass appeared = self.watch_new_dirs() if self.missing else False wanted = {os.path.basename(f) for f in self.files} return appeared or any(n in wanted or n.startswith("appmanifest_") for n in names) class XMessage(ctypes.Structure): _fields_ = [("type", ctypes.c_int), ("serial", ctypes.c_ulong), ("send_event", ctypes.c_int), ("display", ctypes.c_void_p), ("window", ctypes.c_ulong), ("message_type", ctypes.c_ulong), ("format", ctypes.c_int), ("data", ctypes.c_long * 5), ("pad", ctypes.c_long * 20)] X_ERRORS = ctypes.CFUNCTYPE(ctypes.c_int, ctypes.c_void_p, ctypes.c_void_p)(lambda display, error: 0) def window_action(action): if action != "maximize" and action not in WINDOW_MOVES: return False x11 = ctypes.CDLL("libX11.so.6") x11.XOpenDisplay.restype = ctypes.c_void_p x11.XOpenDisplay.argtypes = [ctypes.c_char_p] x11.XDefaultRootWindow.restype = ctypes.c_ulong x11.XDefaultRootWindow.argtypes = [ctypes.c_void_p] x11.XInternAtom.restype = ctypes.c_ulong x11.XInternAtom.argtypes = [ctypes.c_void_p, ctypes.c_char_p, ctypes.c_int] x11.XGetWindowProperty.argtypes = [ctypes.c_void_p, ctypes.c_ulong, ctypes.c_ulong, ctypes.c_long, ctypes.c_long, ctypes.c_int, ctypes.c_ulong] + [ctypes.c_void_p] * 5 x11.XQueryPointer.argtypes = [ctypes.c_void_p, ctypes.c_ulong] + [ctypes.c_void_p] * 7 x11.XSendEvent.argtypes = [ctypes.c_void_p, ctypes.c_ulong, ctypes.c_int, ctypes.c_long, ctypes.c_void_p] x11.XFree.argtypes = [ctypes.c_void_p] x11.XFlush.argtypes = [ctypes.c_void_p] x11.XCloseDisplay.argtypes = [ctypes.c_void_p] x11.XSetErrorHandler(X_ERRORS) display = x11.XOpenDisplay(None) if not display: return False try: root = x11.XDefaultRootWindow(display) atom = lambda name: x11.XInternAtom(display, name, 0) kind, width, count, after = ctypes.c_ulong(), ctypes.c_int(), ctypes.c_ulong(), ctypes.c_ulong() data = ctypes.c_void_p() if x11.XGetWindowProperty(display, root, atom(b"_NET_ACTIVE_WINDOW"), 0, 1, 0, 33, ctypes.byref(kind), ctypes.byref(width), ctypes.byref(count), ctypes.byref(after), ctypes.byref(data)) != 0 or not data.value: return False window = ctypes.cast(data, ctypes.POINTER(ctypes.c_ulong))[0] if count.value else 0 x11.XFree(data) if not window: return False if action == "maximize": kind_name = b"_NET_WM_STATE" values = [2, atom(b"_NET_WM_STATE_MAXIMIZED_VERT"), atom(b"_NET_WM_STATE_MAXIMIZED_HORZ"), 1, 0] else: ignored = ctypes.c_ulong() x, y, inner, mask = ctypes.c_int(), ctypes.c_int(), ctypes.c_int(), ctypes.c_uint() if not x11.XQueryPointer(display, root, ctypes.byref(ignored), ctypes.byref(ignored), ctypes.byref(x), ctypes.byref(y), ctypes.byref(inner), ctypes.byref(inner), ctypes.byref(mask)): return False if not mask.value & 0x100: return False kind_name = b"_NET_WM_MOVERESIZE" values = [x.value, y.value, WINDOW_MOVES[action], 1, 1] message = XMessage(type=33, window=window, message_type=atom(kind_name), format=32) message.data[:] = values sent = x11.XSendEvent(display, root, 0, (1 << 19) | (1 << 20), ctypes.byref(message)) x11.XFlush(display) return bool(sent) finally: x11.XCloseDisplay(display) class Helper: def __init__(self, steam_root, port, steamos=False, files_only=False): self.steam_root = steam_root self.port = port self.steamos = steamos self.files_only = files_only self.page = None self.known = set() self.installed = None self.fex_asked = set() self.tools_asked = {} self.tools_checked = None self.vr_launch = None self.chooser = None self.controls_state = None self.controls_installed = False self.frame_limit_state = None self.frame_limit_retry = 0 self.windows = {} self.windows_retry = 0 def sync_controls(self): try: with open(os.path.join(CONTROLS_DIR, "state.json")) as source: state = json.load(source) value = state.get("brightness") if isinstance(value, bool) or not isinstance(value, (int, float)) or not math.isfinite(value) or not 0 <= value <= 1: return if not self.controls_installed: self.page.call("Runtime.addBinding", {"name": BRIGHTNESS_BINDING}) self.controls_installed = self.page.evaluate(BRIGHTNESS_JS) in ("installed", "present") if not self.controls_installed: return if state != self.controls_state: applied = self.page.evaluate("window.__droiddeckBrightness ? window.__droiddeckBrightness.set(%s) : false" % json.dumps(value)) if applied is True: self.controls_state = state elif applied != "held": self.controls_installed = False self.controls_state = None except (OSError, ValueError, TypeError): pass def sync_windows(self): if os.environ.get("XDG_CURRENT_DESKTOP") != "KDE": return if time.monotonic() >= self.windows_retry: self.windows_retry = time.monotonic() + 2 try: targets = http_get(self.port, "/json/list") except (OSError, ValueError): targets = [] seen = set() for target in targets: url = target.get("webSocketDebuggerUrl") if WINDOW_TARGET not in target.get("url", "").split("&")[0] or not url: continue seen.add(target.get("id")) try: page = self.windows.get(target.get("id")) if page is None: page = Page(self.port, "/" + url.split("/", 3)[3]) page.call("Runtime.addBinding", {"name": WINDOW_BINDING}, timeout=5) self.windows[target.get("id")] = page page.evaluate(WINDOW_JS, timeout=5) except (Closed, OSError, RuntimeError, ValueError) as e: say("window controls: %s" % e) self.windows.pop(target.get("id"), None) for ident in set(self.windows) - seen: del self.windows[ident] for ident, page in list(self.windows.items()): try: for event in page.drain(): if called(event, WINDOW_BINDING): window_action(event.get("params", {}).get("payload")) except (Closed, OSError, ValueError): del self.windows[ident] def sync_frame_limit(self): if self.frame_limit_state in ("installed", "present") or time.monotonic() < self.frame_limit_retry: return try: state = self.page.evaluate(FRAME_LIMIT_JS) except RuntimeError as e: state = "failed (%s)" % e if state != self.frame_limit_state: say("frame limit sync: %s" % state) self.frame_limit_state = state self.frame_limit_retry = time.monotonic() + 10 def open_chooser(self, payload): try: request = json.loads(payload) ident = int(request["id"]) options = request.get("options", {}) if not isinstance(options, dict): raise ValueError("options are not an object") except (ValueError, KeyError, TypeError) as e: say("ignored a file dialog request (%s)" % e) return if self.chooser is not None: self.finish_chooser(ident, None) return command = [sys.executable, os.path.realpath(__file__), "--choose-file"] data = os.environ.get("XDG_DATA_HOME") or os.path.join(os.path.expanduser("~"), ".local", "share") for root in (self.steam_root, os.path.join(data, "Steam")): reaper = os.path.join(root, "steamrtarm64", "reaper") if os.access(reaper, os.X_OK): command = [reaper, "SteamLaunch", "AppId=769", "--"] + command break try: proc = subprocess.Popen(command, stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.DEVNULL, start_new_session=True) proc.stdin.write(json.dumps(options).encode("utf-8")) proc.stdin.close() except OSError as e: say("could not open a file dialog (%s)" % e) self.finish_chooser(ident, None) return say("file dialog open: %s" % (options.get("strTitle") or "untitled")) self.chooser = (ident, proc) def chooser_done(self): ident, proc = self.chooser self.chooser = None out = proc.stdout.read().decode("utf-8", "replace") proc.stdout.close() proc.wait() if proc.returncode == 2: say("file dialog needs GTK 3 and PyGObject, which come with the desktop") try: path = json.loads(out) if proc.returncode == 0 else None except ValueError: path = None self.finish_chooser(ident, path if isinstance(path, str) and path else None) def finish_chooser(self, ident, path): say("file dialog %s" % ("chose " + path if path else "cancelled")) self.page.evaluate("window.__droiddeckFiles?.done(%d, %s)" % (ident, json.dumps(path))) def close_chooser(self): if self.chooser is not None: _, proc = self.chooser self.chooser = None try: os.killpg(proc.pid, signal.SIGTERM) except OSError: pass proc.stdout.close() proc.wait() def attach(self): path = shared_context(self.port) if path is None: raise LookupError("no SharedJSContext yet") page = Page(self.port, path) try: if page.evaluate("typeof SteamClient === 'object' && typeof SteamClient.WebUITransport === 'object'") is not True: raise LookupError("SteamClient is not ready") if self.files_only: page.call("Runtime.addBinding", {"name": FILE_BINDING}) page.evaluate(FILE_JS) page.evaluate(LIBRARY_ART_JS) self.page = page self.controls_state = None self.controls_installed = False self.sync_controls() return True page.call("Runtime.addBinding", {"name": BINDING}) page.call("Runtime.addBinding", {"name": VR_BINDING}) page.evaluate(VR_JS) page.call("Runtime.addBinding", {"name": FILE_BINDING}) page.evaluate(FILE_JS) page.evaluate(LIBRARY_ART_JS) try: page.evaluate(TOUR_JS) except RuntimeError: pass if not self.steamos: page.call("Runtime.addBinding", {"name": SWITCH_BINDING}) page.evaluate(SWITCH_JS) page.compat("get(0)") except Exception: page.ws.close() raise self.page = page self.controls_state = None self.controls_installed = False self.frame_limit_state = None self.frame_limit_retry = 0 self.sync_controls() return True def reconcile(self): page = self.page with COMPAT["locked"](): state_file = COMPAT["state_path"]("state.json") state = COMPAT["read_json"](state_file) request = COMPAT["read_json"](COMPAT["state_path"]("request.json")) catalog = COMPAT["tool_catalog"](self.steam_root) top = page.compat("get(0)") self.known = set(top["tools"]) live = [t for t in catalog if t["name"] in self.known] wanted = COMPAT["requested_tool"](request, catalog) newer = isinstance(request.get("seq"), int) and request["seq"] > int(state.get("applied", 0) or 0) waiting = newer and wanted is not None and wanted not in self.known listed = [t["name"] for t in live] default, state = COMPAT["choose_default"](COMPAT["built_from"](top["selected"], catalog, listed) or top["selected"], state, request, catalog, apply_request=not waiting, listed=listed) installed = COMPAT["installed_apps"](self.steam_root) self.installed = installed picks = COMPAT["valve_picks"](self.steam_root) tools = COMPAT["tool_platforms"](self.steam_root) prior_auto = state.get("auto", {}) if not isinstance(prior_auto, dict): prior_auto = {} prior_native = state.get("native_choices", ()) native_choices = set(prior_native if isinstance(prior_native, (list, tuple, set)) else ()) picked = COMPAT["picked_apps"](state) runnable = {t["name"].lower() for t in live} apps = sorted(set(installed) | set(picks) | set(prior_auto) | native_choices | set(tools), key=COMPAT["app_order"]) asked = [app for app, request in COMPAT["game_requests"]().items() if COMPAT["valid_game_request"](app, request)] apps = sorted(set(apps) | set(asked), key=COMPAT["app_order"]) current = dict(page.compat("many(%s)" % json.dumps(apps)) or {}) refused = set(apps) - set(current) refused_native = native_choices & refused if refused: apps = [app for app in apps if app not in refused] installed = [app for app in installed if app not in refused] picks = [app for app in picks if app not in refused] prior_auto = {app: tool for app, tool in prior_auto.items() if app not in refused} if isinstance(state.get("auto"), dict): state["auto"] = prior_auto native_choices -= refused tools = {app: platforms for app, platforms in tools.items() if app not in refused} current["0"] = top["selected"] native = COMPAT["native_targets"](self.steam_root, apps) raw_mapping = COMPAT["read_config_mapping"]( os.path.join(self.steam_root, "config", "config.vdf")) if raw_mapping is None: for app in native_choices: current[app] = "" for app in set(native) - native_choices: if not current.get(app) and app not in picked: current.pop(app, None) else: for app in set(native) | native_choices: if app in raw_mapping: if raw_mapping[app] == "" or current.get(app) not in self.known: current[app] = raw_mapping[app] elif app in prior_auto or app in native_choices or app in picked and ( not current.get(app) or COMPAT["unrunnable"](current[app], runnable)): current[app] = "" elif not current.get(app): current.pop(app, None) moved = COMPAT["rebuilt_picks"](current, catalog, set(prior_auto) | picked, listed) if moved: following = COMPAT["followers"](state, current) state["auto"] = {app: name for app, name in following.items() if app not in moved} if isinstance(following, dict) else {} prior_auto = {app: name for app, name in prior_auto.items() if app not in moved} current.update(moved) requests = COMPAT["settled_game_requests"](state, current, catalog) overrides = COMPAT["requested_games"](requests or {}, catalog, listed) overrides = {app: tool for app, tool in overrides.items() if app not in refused} changes, auto = COMPAT["plan_mapping"]( current, installed, listed, default, COMPAT["followers"](state, current), native, picks, overrides, prior_auto.keys(), native_choices, tools) changes = dict(moved, **changes) for app, tool in sorted(changes.items(), key=lambda item: COMPAT["app_order"](item[0])): page.compat("set(%d, %s)" % (int(app), json.dumps(tool if tool is not None else ""))) say("%s -> %s" % ("default" if app == "0" else "app %s" % app, tool if tool is not None else "Steam native default")) state.update( auto={app: tool for app, tool in auto.items() if tool is not COMPAT["NATIVE_CHOICE"]}, native_choices=sorted(refused_native | {app for app, tool in auto.items() if tool is COMPAT["NATIVE_CHOICE"]}), picked=COMPAT["picked_after"](current, changes), tools=catalog, live=True, written=default, games_applied=COMPAT["applied_game_requests"](requests, overrides, state)) state.pop("native", None) if waiting: state["pending"] = wanted say("%s is new to the running client; it applies when Steam next starts" % wanted) else: state.pop("pending", None) COMPAT["write_json"](state_file, state) def ensure_tools(self): now = time.monotonic() if self.tools_checked is not None and now - self.tools_checked < TOOL_CHECK_SECONDS: return self.tools_checked = now if COMPAT["game_running"](): return for app, action in COMPAT["tool_downloads"](self.steam_root): if now - self.tools_asked.get(app, -TOOL_RETRY_SECONDS) < TOOL_RETRY_SECONDS: continue self.tools_asked[app] = now try: self.page.tools("%s(%d)" % (action, int(app))) say("asked the client to %s %s" % (action, app)) except Exception as e: say("the client could not %s %s (%s)" % (action, app, e)) if action == "install": for asked in COMPAT["request_fex"](self.steam_root, self.fex_asked): say("asked the client to install %s through steam://install" % asked) def request_waiting(self): request = COMPAT["read_json"](COMPAT["state_path"]("request.json")) state = COMPAT["read_json"](COMPAT["state_path"]("state.json")) return isinstance(request.get("seq"), int) and request["seq"] > int(state.get("applied", 0) or 0) def drain(self): events = self.page.drain() if any(called(e, SWITCH_BINDING) for e in events): switch_to_desktop() vr_games = {e.get("params", {}).get("payload") for e in events if called(e, VR_BINDING) and isinstance(e.get("params", {}).get("payload"), str)} vr_games = {game for game in vr_games if isinstance(game, str) and game.isascii() and game.isdecimal() and not game.startswith("0") and len(game) <= 20 and int(game) <= 0xffffffffffffffff} if vr_games and (self.vr_launch is None or self.vr_launch.poll() is not None): say("preparing SteamVR for library app(s): " + ", ".join(sorted(vr_games))) self.vr_launch = launch_steamvr() for e in events: if called(e, BRIGHTNESS_BINDING): brightness_request(e.get("params", {}).get("payload")) if called(e, FILE_BINDING) and isinstance(e.get("params", {}).get("payload"), str): self.open_chooser(e["params"]["payload"]) return events def serve_files(self): say("attached to the client on port %d for its file dialogs" % self.port) while True: self.sync_controls() self.sync_windows() sources = [self.page.ws] + ([self.chooser[1].stdout] if self.chooser is not None else []) sources += [page.ws for page in self.windows.values()] queued = self.page.ws.pending() or bool(self.page.events) ready = [self.page.ws] if queued else select.select(sources, [], [], 0.25)[0] if self.chooser is not None and self.chooser[1].stdout in ready: self.chooser_done() if self.page.ws in ready or self.page.events: self.drain() def serve(self, watcher): if self.files_only: return self.serve_files() with open(COMPAT["state_path"]("live.pid"), "w") as f: f.write("%d\n" % os.getpid()) say("attached to the client on port %d" % self.port) self.reconcile() self.ensure_tools() while True: self.sync_controls() self.sync_frame_limit() self.sync_windows() sources = [self.page.ws] + ([watcher] if watcher.fileno() >= 0 else []) sources += [page.ws for page in self.windows.values()] if self.chooser is not None: sources.append(self.chooser[1].stdout) queued = self.page.ws.pending() or bool(self.page.events) ready = [self.page.ws] if queued else select.select(sources, [], [], 0.25)[0] if self.chooser is not None and self.chooser[1].stdout in ready: self.chooser_done() due = False if self.page.ws in ready: due = any(called(e, BINDING) for e in self.drain()) if (watcher in ready or watcher.fileno() < 0) and watcher.changed(): due = True if due: time.sleep(0.3) if watcher.fileno() >= 0 and select.select([watcher], [], [], 0)[0]: watcher.changed() self.drain() self.reconcile() self.ensure_tools() def detach(): try: os.unlink(COMPAT["state_path"]("live.pid")) except OSError: pass with COMPAT["locked"](): state_file = COMPAT["state_path"]("state.json") state = COMPAT["read_json"](state_file) if state.get("live"): state["live"] = False COMPAT["write_json"](state_file, state) def chooser_main(): try: options = json.load(sys.stdin) except ValueError: return 1 try: path = choose_file(options if isinstance(options, dict) else {}) except (ImportError, ValueError): return 2 if not path: return 1 print(json.dumps(path)) return 0 def main(): files_only = sys.argv[1:2] == ["--files-only"] steam_root = sys.argv[2 if files_only else 1] try: port = int(os.environ.get("DD_CDP_PORT", "")) except ValueError: say("no devtools port for this session; the client's mapping is kept through config.vdf") return 0 if files_only: helper = Helper(steam_root, port, files_only=True) failures = 0 while True: try: helper.attach() failures = 0 helper.serve(None) except Exception as e: helper.close_chooser() if helper.page is not None: say("lost the client (%s); reattaching" % e) helper.page.ws.close() helper.page = None failures += 1 time.sleep(min(2 * max(failures, 1), 10)) os.makedirs(COMPAT["COMPAT_DIR"], exist_ok=True) watcher = Watcher([COMPAT["state_path"]("request.json"), COMPAT["state_path"]("games.json"), os.path.join(steam_root, "appcache", "appinfo.vdf")] + [os.path.join(lib, "steamapps", "libraryfolders.vdf") for lib in (steam_root, COMPAT["LIBRARY"] + "-sd")]) steamos = os.environ.get("DD_STEAMDECK") == "1" and os.environ.get("DD_STEAM_UI") != "desktop" helper = Helper(steam_root, port, steamos) failures = 0 last = None while True: try: helper.attach() failures = 0 last = None helper.serve(watcher) except Exception as e: helper.close_chooser() if helper.page is not None: say("lost the client (%s); reattaching" % e) helper.page.ws.close() helper.page = None detach() elif str(e) != last: say("waiting for the client (%s)" % e) last = str(e) failures += 1 time.sleep(min(2 * max(failures, 1), 10)) if __name__ == "__main__": if sys.argv[1:2] == ["--choose-file"]: sys.exit(chooser_main()) signal.signal(signal.SIGTERM, lambda *_: sys.exit(0)) try: sys.exit(main()) finally: if sys.argv[1:2] != ["--files-only"]: detach()