agentstreamdeck 2.1.1__py3-none-any.whl

ocdeck/broker.py

@@ -0,0 +1,273 @@
+import hmac
+from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
+import json
+import logging
+from .observability import configure, tail, correlation
+from .alerts import Alerts
+from .security import scrub
+import uuid
+import os
+from pathlib import Path
+import queue
+import secrets
+import threading
+import time
+import urllib.parse
+
+from .common import alive, atomic_json, home, identity, read_json, load_config
+from .device import DeviceLoop
+from .focus import activate
+from .model import Registry
+from .errors import message
+from .settings import validate_config
+
+LOG = logging.getLogger(__name__)
+
+
+class InstanceLock:
+    def __init__(self, root):
+        self.path = root / "broker.lock"
+
+    def __enter__(self):
+        self.f = open(self.path, "a+b")
+        try:
+            self.f.seek(0)
+            if os.name == "nt":
+                import msvcrt
+
+                if not self.f.read(1):
+                    self.f.write(b"0")
+                    self.f.flush()
+                self.f.seek(0)
+                msvcrt.locking(self.f.fileno(), msvcrt.LK_NBLCK, 1)
+            else:
+                import fcntl
+
+                fcntl.flock(self.f.fileno(), fcntl.LOCK_EX | fcntl.LOCK_NB)
+        except Exception:
+            self.f.close()
+            raise
+        return self
+
+    def __exit__(self, *args):
+        self.f.close()
+
+
+class Broker:
+    def __init__(self, root=None, mock=False, probe=alive, focus=activate):
+        self.root = Path(root or home())
+        self.root.mkdir(parents=True, exist_ok=True)
+        saved = load_config(self.root)
+        validate_config(saved)
+        self.config = {
+            "fps": 24,
+            "brightness": 45,
+            "animations": True,
+            "ready": True,
+            "check_updates": not mock,
+            **saved,
+        }
+        if not (self.root / "token").exists():
+            fd = os.open(self.root / "token", os.O_CREAT | os.O_EXCL | os.O_WRONLY, 0o600)
+            with os.fdopen(fd, "w", encoding="ascii") as f:
+                f.write(secrets.token_hex(32))
+        self.token = (self.root / "token").read_text(encoding="ascii").strip()
+        self.registry = Registry(probe, slots=self.config.get("slots", 6), secrets=(self.token,))
+        self.alerts = Alerts(self.config)
+        self.update = None
+        self.stop = threading.Event()
+        self.presses = queue.Queue(maxsize=64)
+        self.device = DeviceLoop(self.registry, self.presses, self.stop, self.config, mock)
+        self.focus = focus
+        self.last_focus = None
+        self.last_press = {}
+        self.server = None
+
+    def dispatch(self, method, path, body):
+        if method == "GET" and path == "/v1/status":
+            with self.registry.lock:
+                overflow = sum(r["slot"] is None for r in self.registry.records.values())
+            return {
+                "epoch": self.registry.epoch,
+                "device": dict(self.device.status),
+                "slots": self.registry.view(),
+                "overflow": overflow,
+                "lastFocus": scrub(self.last_focus, (self.token,)),
+                "brokerPid": os.getpid(),
+                "recentErrors": tail(self.root, 10, errors_only=True),
+                "update": self.update,
+            }
+        if method == "POST" and path == "/v1/register":
+            record = self.registry.upsert(body)
+            return {"epoch": self.registry.epoch, "slot": record["slot"]}
+        if path.startswith("/v1/instances/"):
+            key = urllib.parse.unquote(path[len("/v1/instances/") :])
+            if method == "PUT":
+                with self.registry.lock:
+                    accepted = self.registry.snapshot(key, body)
+                    if accepted:
+                        self.alerts.observe(self.registry.view())
+                return {"accepted": accepted, "epoch": self.registry.epoch}
+            if method == "DELETE":
+                self.registry.remove(key)
+                return {"ok": True}
+        if method == "POST" and path == "/v1/focus":
+            return self.handle_press(body, synthetic=True)
+        if method == "POST" and path == "/v1/stop":
+            self.stop.set()
+            return {"ok": True}
+        raise KeyError("Unknown route")
+
+    def handle_press(self, view, synthetic=False):
+        r = self.registry.resolve(view.get("slot"), view.get("generation"), view.get("id"))
+        if not r:
+            return {"ok": False, "reason": "Empty or stale slot"}
+        now = time.monotonic()
+        if now - self.last_press.get(r["id"], -100) < 0.2:
+            return {"ok": False, "reason": "Debounced"}
+        self.last_press[r["id"]] = now
+        outcome = self.focus(r)
+        if not outcome.get("ok"):
+            outcome = {**outcome, "fix": message("AD006")}
+        self.last_focus = {**outcome, "id": r["id"], "synthetic": synthetic, "time": time.time()}
+        LOG.info("Focus %s", self.last_focus)
+        return self.last_focus
+
+    def check_update(self):
+        from .updates import check
+
+        self.update = check(self.root, self.config)
+
+    def serve(self):
+        broker = self
+
+        class Handler(BaseHTTPRequestHandler):
+            protocol_version = "HTTP/1.0"
+
+            def setup(self):
+                super().setup()
+                self.connection.settimeout(3)
+
+            def log_message(self, *args):
+                pass
+
+            def handle_request(self):
+                context = correlation.set(uuid.uuid4().hex)
+                try:
+                    if self.headers.get("Origin"):
+                        self.send_json(403, {"error": message("AD007", "Browser origins are not accepted")})
+                        return
+                    expected = "Bearer " + broker.token
+                    if not hmac.compare_digest(self.headers.get("Authorization", ""), expected):
+                        self.send_json(401, {"error": message("AD007")})
+                        return
+                    size = int(self.headers.get("Content-Length", "0"))
+                    if not 0 <= size <= 65536:
+                        self.send_json(413, {"error": message("AD004", "Body too large")})
+                        return
+                    raw = self.rfile.read(size)
+                    if len(raw) != size:
+                        raise ValueError("Incomplete body")
+                    data = json.loads(raw) if raw else {}
+                    if not isinstance(data, dict):
+                        raise ValueError("Expected object")
+                    result = broker.dispatch(self.command, urllib.parse.urlsplit(self.path).path, data)
+                    self.send_json(200, result)
+                except KeyError:
+                    self.send_json(404, {"error": message("AD005")})
+                except (ValueError, TypeError) as e:
+                    self.send_json(400, {"error": message("AD004", str(e))})
+                except Exception:
+                    LOG.exception(message("AD500"))
+                    self.send_json(500, {"error": message("AD500")})
+                finally:
+                    correlation.reset(context)
+
+            def send_json(self, code, value):
+                data = json.dumps(scrub(value, (broker.token,))).encode()
+                self.send_response(code)
+                self.send_header("Content-Type", "application/json")
+                self.send_header("Cache-Control", "no-store")
+                self.send_header("Content-Length", str(len(data)))
+                self.end_headers()
+                try:
+                    self.wfile.write(data)
+                except OSError:
+                    pass
+
+            do_GET = do_POST = do_PUT = do_DELETE = handle_request
+
+        class Server(ThreadingHTTPServer):
+            daemon_threads = True
+
+            def __init__(self, *args):
+                self.limit = threading.BoundedSemaphore(16)
+                super().__init__(*args)
+
+            def process_request(self, sock, address):
+                if not self.limit.acquire(blocking=False):
+                    sock.close()
+                    return
+                try:
+                    super().process_request(sock, address)
+                except Exception:
+                    self.limit.release()
+                    raise
+
+            def process_request_thread(self, *args):
+                try:
+                    super().process_request_thread(*args)
+                finally:
+                    self.limit.release()
+
+        self.server = Server(("127.0.0.1", 0), Handler)
+        atomic_json(
+            self.root / "discovery.json",
+            {"port": self.server.server_address[1], "epoch": self.registry.epoch, "process": identity()},
+        )
+        threads = [
+            threading.Thread(target=self.server.serve_forever, daemon=True),
+            threading.Thread(target=self.device.run, daemon=True),
+            threading.Thread(target=self.alerts.run, args=(self.stop,), daemon=True),
+            threading.Thread(target=self.check_update, daemon=True),
+        ]
+        for thread in threads:
+            thread.start()
+        LOG.info("Broker ready on OS-assigned port %s", self.server.server_address[1])
+        try:
+            next_sweep = 0
+            while not self.stop.is_set():
+                if time.monotonic() >= next_sweep:
+                    self.registry.sweep()
+                    next_sweep = time.monotonic() + 0.5
+                try:
+                    self.handle_press(self.presses.get(timeout=0.1))
+                except queue.Empty:
+                    pass
+                except Exception:
+                    LOG.exception(message("AD006"))
+        finally:
+            self.stop.set()
+            self.server.shutdown()
+            self.server.server_close()
+            for thread in threads:
+                thread.join(timeout=3)
+            discovery = read_json(self.root / "discovery.json", {})
+            if discovery.get("epoch") == self.registry.epoch:
+                (self.root / "discovery.json").unlink(missing_ok=True)
+
+
+def run(root=None, mock=False):
+    root = Path(root or home())
+    root.mkdir(parents=True, exist_ok=True)
+    try:
+        with InstanceLock(root):
+            broker = Broker(root, mock=mock)
+            configure(root)
+            import signal
+
+            for sig in (signal.SIGINT, signal.SIGTERM):
+                signal.signal(sig, lambda *_: broker.stop.set())
+            broker.serve()
+    except (BlockingIOError, PermissionError):
+        LOG.info(message("AD008"))

ocdeck/common.py

@@ -0,0 +1,82 @@
+import json
+import os
+from pathlib import Path
+import tempfile
+import urllib.request
+
+
+def home():
+    return Path(os.environ.get("OCDECK_HOME", Path.home() / ".opencode-deck"))
+
+
+def atomic_json(path, data):
+    path = Path(path)
+    path.parent.mkdir(parents=True, exist_ok=True)
+    fd, temp = tempfile.mkstemp(dir=path.parent, prefix=".write-")
+    try:
+        with os.fdopen(fd, "w", encoding="utf-8") as f:
+            json.dump(data, f, indent=2)
+        os.replace(temp, path)
+    finally:
+        if os.path.exists(temp):
+            os.unlink(temp)
+
+
+def read_json(path, default=None):
+    try:
+        return json.loads(Path(path).read_text(encoding="utf-8-sig"))
+    except (OSError, ValueError):
+        return default
+
+
+def load_config(root=None):
+    path = Path(root or home()) / "config.json"
+    if not path.exists():
+        return {}
+    value = json.loads(path.read_text(encoding="utf-8-sig"))
+    if not isinstance(value, dict):
+        raise ValueError("config.json must contain an object")
+    return value
+
+
+def request(method, path, data=None, root=None, timeout: float = 2):
+    root = Path(root or home())
+    discovery = read_json(root / "discovery.json")
+    if not discovery:
+        raise ConnectionError("Broker is not running; start its scheduled task.")
+    # Discovery cannot redirect a privileged local client to a remote URL.
+    port = int(discovery["port"])
+    if not 1 <= port <= 65535:
+        raise ValueError("Invalid broker port")
+    token = (root / "token").read_text(encoding="ascii").strip()
+    req = urllib.request.Request(
+        f"http://127.0.0.1:{port}{path}",
+        data=json.dumps(data).encode() if data is not None else None,
+        method=method,
+        headers={"Authorization": "Bearer " + token, "Content-Type": "application/json"},
+    )
+    with urllib.request.urlopen(req, timeout=timeout) as response:
+        return json.load(response)
+
+
+def identity(pid=None):
+    import psutil
+
+    p = psutil.Process(pid or os.getpid())
+    return {"pid": p.pid, "created": p.create_time()}
+
+
+def alive(process):
+    import psutil
+
+    try:
+        p = psutil.Process(int(process["pid"]))
+        return (
+            abs(p.create_time() - float(process["created"])) < 0.01
+            and p.is_running()
+            and p.status() != psutil.STATUS_ZOMBIE
+        )
+    except psutil.AccessDenied:
+        return None
+    except (psutil.NoSuchProcess, KeyError, ValueError, TypeError):
+        return False

ocdeck/device.py

@@ -0,0 +1,247 @@
+"""HID adapter using the pip hidapi wheel, avoiding a manual hidapi.dll install."""
+
+import logging
+import queue
+import threading
+import time
+from .art import frame
+from .errors import message
+from .appearance import appearance, animation_phase, harness_id
+from collections import OrderedDict
+
+LOG = logging.getLogger(__name__)
+MINI_PIDS = {0x0063, 0x0090, 0x00B3, 0x00B8}
+
+
+class WheelTransport:
+    """StreamDeck transport duck type backed by cython-hidapi's bundled library."""
+
+    def __init__(self, info):
+        self.info, self.handle = info, None
+        self.lock = threading.RLock()
+
+    def open(self):
+        import hid
+
+        with self.lock:
+            if self.handle is None:
+                h = hid.device()
+                h.open_path(self.info["path"])
+                h.set_nonblocking(True)
+                self.handle = h
+
+    def close(self):
+        with self.lock:
+            if self.handle:
+                self.handle.close()
+                self.handle = None
+
+    def is_open(self):
+        return self.handle is not None
+
+    def connected(self):
+        import hid
+
+        return any(x["path"] == self.info["path"] for x in hid.enumerate(0x0FD9, self.product_id()))
+
+    def path(self):
+        return self.info["path"]
+
+    def vendor_id(self):
+        return self.info["vendor_id"]
+
+    def product_id(self):
+        return self.info["product_id"]
+
+    def _call(self, method, *args):
+        from StreamDeck.Transport.Transport import TransportError
+
+        try:
+            with self.lock:
+                if self.handle is None:
+                    raise OSError("Device is closed")
+                return getattr(self.handle, method)(*args)
+        except (OSError, ValueError) as e:
+            raise TransportError(str(e)) from e
+
+    def write(self, payload):
+        result = self._call("write", bytes(payload))
+        if result != len(payload):
+            from StreamDeck.Transport.Transport import TransportError
+
+            raise TransportError(f"Short HID write: {result}/{len(payload)}")
+        return result
+
+    def write_feature(self, payload):
+        return self._call("send_feature_report", bytes(payload))
+
+    def read_feature(self, report_id, length):
+        return bytes(self._call("get_feature_report", report_id, length))
+
+    def read(self, length):
+        value = self._call("read", length)
+        return bytes(value) if value else None
+
+
+def device_types():
+    from StreamDeck.Devices.StreamDeckMini import StreamDeckMini
+    from StreamDeck.Devices.StreamDeckOriginal import StreamDeckOriginal
+    from StreamDeck.Devices.StreamDeckOriginalV2 import StreamDeckOriginalV2
+    from StreamDeck.Devices.StreamDeckXL import StreamDeckXL
+
+    return {
+        **{p: StreamDeckMini for p in MINI_PIDS},
+        0x60: StreamDeckOriginal,
+        **{p: StreamDeckOriginalV2 for p in (0x6D, 0x80, 0xA5, 0xB9)},
+        **{p: StreamDeckXL for p in (0x6C, 0x8F, 0xBA)},
+    }
+
+
+def elgato_running():
+    import psutil
+
+    for process in psutil.process_iter(["name"]):
+        try:
+            if (process.info["name"] or "").lower() in ("streamdeck.exe", "stream deck.exe", "stream deck"):
+                return True
+        except (psutil.NoSuchProcess, psutil.AccessDenied):
+            pass
+    return False
+
+
+def enumerate_devices():
+    import hid
+
+    types = device_types()
+    result = []
+    for d in hid.enumerate(0x0FD9, 0):
+        if d["product_id"] in types:
+            deck = types[d["product_id"]](WheelTransport(d))
+            result.append({**d, "model": deck.deck_type(), "keys": deck.key_count()})
+    return result
+
+
+def enumerate_minis():
+    import hid
+
+    return [d for d in hid.enumerate(0x0FD9, 0) if d["product_id"] in MINI_PIDS]
+
+
+class DeviceLoop:
+    def __init__(self, registry, presses, stop, config, mock=False):
+        self.registry, self.presses, self.stop, self.config, self.mock = registry, presses, stop, config, mock
+        self.status = {"online": False, "mock": mock, "error": "Not connected", "frames": 0}
+        self.presented: list[dict | None] = [None] * len(self.registry.slots)
+        self.presented_lock = threading.Lock()
+        self.deck = None
+
+    def press(self, key, state):
+        if not state or not 0 <= key < len(self.presented):
+            return
+        with self.presented_lock:
+            view = self.presented[key]
+            if view:
+                try:
+                    self.presses.put_nowait(dict(view))
+                except queue.Full:
+                    LOG.warning("Press queue full; dropping press")
+
+    def run(self):
+        from PIL import Image
+
+        while not self.stop.is_set():
+            try:
+                if not self.mock:
+                    from StreamDeck.ImageHelpers import PILHelper
+
+                    devices = enumerate_devices()
+                    serial = self.config.get("serial")
+                    if serial:
+                        devices = [d for d in devices if d.get("serial_number") == serial]
+                    if len(devices) != 1:
+                        raise RuntimeError(
+                            f"Found {len(devices)} matching decks; select serial in config.json if multiple"
+                        )
+                    if elgato_running() and not self.config.get("allow_elgato", False):
+                        raise RuntimeError(
+                            "AD001: Elgato is running. Quit Stream Deck from its tray menu, then run ocdeck doctor."
+                        )
+                    self.deck = device_types()[devices[0]["product_id"]](WheelTransport(devices[0]))
+                    self.deck.open()
+                    self.registry.resize(self.deck.key_count())
+                    self.presented = [None] * self.deck.key_count()
+                    self.deck.set_brightness(int(self.config.get("brightness", 45)))
+                    blank = PILHelper.to_native_key_format(self.deck, Image.new("RGB", (80, 80), "black"))
+                    for k in range(len(self.registry.slots)):
+                        self.deck.set_key_image(k, blank)
+                    self.deck.set_key_callback(lambda deck, key, state: self.press(key, state))
+                    self.status.update(serial=devices[0].get("serial_number"), productId=devices[0]["product_id"])
+                self.status.update(online=True, error="", keys=len(self.registry.slots))
+                last, native = {}, OrderedDict()
+                styles = [appearance(self.config, k) for k in range(len(self.registry.slots))]
+                next_probe = time.monotonic() + 2
+                fps = max(1, min(30, int(self.config.get("fps", 24))))
+                while not self.stop.is_set():
+                    start = time.monotonic()
+                    if not self.mock and start >= next_probe:
+                        assert self.deck is not None
+                        if not self.deck.is_open() or not self.deck.connected():
+                            raise OSError("Mini disconnected")
+                        next_probe = start + 2
+                    views = self.registry.view()
+                    if not any(v["id"] for v in views) and self.config.get("ready", True):
+                        views[0] = {**views[0], "state": "ready"}
+                    for k, v in enumerate(views):
+                        style = styles[k]
+                        phase = animation_phase(start, style, self.config.get("animations", True))
+                        key = (
+                            v["state"],
+                            v["label"],
+                            k,
+                            phase if v["state"] != "off" else 0,
+                            (self.deck.key_image_format()["size"][0] if self.deck else 80),
+                            style,
+                            harness_id(v["label"], v.get("harness", "")),
+                            v.get("detail", "") if "detail" in (style.primary, style.secondary) else "",
+                            v.get("pending"),
+                        )
+                        # Assignment identity must refresh even when the pixels are identical.
+                        if last.get(k) == key:
+                            with self.presented_lock:
+                                self.presented[k] = dict(v)
+                            continue
+                        if not self.mock:
+                            assert self.deck is not None
+                            if key not in native:
+                                if len(native) >= 768:
+                                    native.popitem(last=False)
+                                native[key] = PILHelper.to_native_key_format(self.deck, frame(*key))
+                            native.move_to_end(key)
+                            self.deck.set_key_image(k, native[key])
+                        with self.presented_lock:
+                            self.presented[k] = dict(v)
+                        last[k] = key
+                        self.status["frames"] += 1
+                    self.stop.wait(max(0, 1 / fps - (time.monotonic() - start)))
+            except Exception as error:
+                LOG.warning(message("AD002", str(error)))
+                self.status.update(online=False, error=message("AD002", str(error)))
+            finally:
+                if self.deck:
+                    try:
+                        if self.stop.is_set():
+                            from StreamDeck.ImageHelpers import PILHelper
+
+                            blank = PILHelper.to_native_key_format(self.deck, Image.new("RGB", (80, 80), "black"))
+                            for k in range(len(self.registry.slots)):
+                                self.deck.set_key_image(k, blank)
+                    except Exception:
+                        pass
+                    try:
+                        self.deck.close()
+                    except Exception:
+                        pass
+                    self.deck = None
+                with self.presented_lock:
+                    self.presented = [None] * len(self.registry.slots)
+            self.stop.wait(2)