Skip to content

The agent that grows with you

2.6 KB
Raw Blame
"""Keep Windows console backpressure off the packaged desktop startup path."""

import logging
import os
import sys
import threading
import time
from contextlib import contextmanager

logger = logging.getLogger("hermes_cli.desktop")


def desktop_launch_notice(message: str, *, source_mode: bool = False) -> None:
    if sys.platform == "win32" and not source_mode:
        # setup_logging() uses an async queue and rotating, redacted files.
        logger.info(message)
    else:
        print(message)


@contextmanager
def desktop_console_output(*, source_mode: bool):
    """Drain packaged Windows stdout/stderr into the existing rotating logs.

    Inheriting the console lets an unresponsive console host/profiler block
    Electron's synchronous startup messages before it can create a window.
    Keep source launches interactive and preserve subprocess.run's lifecycle
    and exit-code handling. Read bounded lines so output cannot grow a buffer
    without limit, and never wait indefinitely on a descendant's open pipe.
    """
    if sys.platform != "win32" or source_mode:
        yield {}
        return

    def drain(read_fd, level):
        with os.fdopen(read_fd, "rb") as stream:
            # Decode/redact complete records, not arbitrary pipe-read fragments.
            # Discard an oversized line in full: even its prefix may be a secret.
            limit = 128 * 1024
            while data := stream.readline(limit + 1):
                if len(data) > limit:
                    while data and not data.endswith(b"\n"):
                        data = stream.readline(8192)
                    logger.log(level, "[desktop] [oversized line omitted]")
                else:
                    logger.log(level, "[desktop] %s", data.decode("utf-8", errors="replace").rstrip())

    streams = {}
    readers = []
    try:
        # Keep diagnostics visible even when ordinary INFO output is disabled.
        for name, level in (("stdout", logging.INFO), ("stderr", logging.ERROR)):
            read_fd, write_fd = os.pipe()
            streams[name] = write_fd
            reader = threading.Thread(
                target=drain, args=(read_fd, level), name=f"desktop-console-{name}", daemon=True,
            )
            try:
                reader.start()
            except BaseException:
                os.close(read_fd)
                raise
            readers.append(reader)
        yield streams
    finally:
        for write_fd in streams.values():
            os.close(write_fd)
        deadline = time.monotonic() + 1
        for reader in readers:
            reader.join(timeout=max(0, deadline - time.monotonic()))