Skip to content

armgit / orca

Public Imported from GitHub
0

Orca is the place for working with a fleet of agents (e.g. Grok Bot, Claude Code). Run any coding agent with your own subscription. Available on desktop, mobile and remote runtime.

9.1 KB
Raw Blame
"""Windows host observation (foreground, z-order, cursor, clipboard) and the user's typer, via user32."""
import ctypes
import ctypes.wintypes as W
import threading
import time

try:
    ctypes.windll.shcore.SetProcessDpiAwareness(2)
except Exception:
    ctypes.windll.user32.SetProcessDPIAware()

u = ctypes.WinDLL("user32", use_last_error=True)
k32 = ctypes.WinDLL("kernel32", use_last_error=True)

GW_HWNDPREV = 3
WM_GETTEXT, WM_GETTEXTLENGTH, WM_SETTEXT = 0x000D, 0x000E, 0x000C
EM_GETSEL, EM_SETSEL, EM_GETFIRSTVISIBLELINE, EM_LINESCROLL = 0x00B0, 0x00B1, 0x00CE, 0x00B6
WM_VSCROLL, SB_TOP = 0x0115, 6
SMTO_ABORTIFHUNG = 0x2
SWP_NOACTIVATE, SWP_NOZORDER = 0x0010, 0x0004
SPI_GETFOREGROUNDLOCKTIMEOUT = 0x2000

ULONG_PTR = ctypes.c_size_t


class KEYBDINPUT(ctypes.Structure):
    _fields_ = [("wVk", W.WORD), ("wScan", W.WORD), ("dwFlags", W.DWORD), ("time", W.DWORD), ("dwExtraInfo", ULONG_PTR)]


class MOUSEINPUT(ctypes.Structure):
    _fields_ = [("dx", W.LONG), ("dy", W.LONG), ("mouseData", W.DWORD), ("dwFlags", W.DWORD), ("time", W.DWORD), ("dwExtraInfo", ULONG_PTR)]


class _U(ctypes.Union):
    _fields_ = [("ki", KEYBDINPUT), ("mi", MOUSEINPUT)]


class INPUT(ctypes.Structure):
    _fields_ = [("type", W.DWORD), ("u", _U)]


WNDENUMPROC = ctypes.WINFUNCTYPE(W.BOOL, W.HWND, W.LPARAM)
u.EnumWindows.argtypes = [WNDENUMPROC, W.LPARAM]
u.GetWindowThreadProcessId.argtypes = [W.HWND, ctypes.POINTER(W.DWORD)]
u.GetWindowThreadProcessId.restype = W.DWORD
u.GetForegroundWindow.restype = W.HWND
u.GetWindow.restype = W.HWND
u.GetWindow.argtypes = [W.HWND, W.UINT]
u.FindWindowExW.restype = W.HWND
u.FindWindowExW.argtypes = [W.HWND, W.HWND, W.LPCWSTR, W.LPCWSTR]
u.SendMessageTimeoutW.argtypes = [W.HWND, W.UINT, W.WPARAM, W.LPARAM, W.UINT, W.UINT, ctypes.POINTER(ULONG_PTR)]
u.SendMessageTimeoutW.restype = W.LPARAM
u.SetWindowPos.argtypes = [W.HWND, W.HWND, ctypes.c_int, ctypes.c_int, ctypes.c_int, ctypes.c_int, W.UINT]
u.SendInput.argtypes = [W.UINT, ctypes.POINTER(INPUT), ctypes.c_int]
u.AttachThreadInput.argtypes = [W.DWORD, W.DWORD, W.BOOL]
u.SetForegroundWindow.argtypes = [W.HWND]
u.BringWindowToTop.argtypes = [W.HWND]
u.IsWindowVisible.argtypes = [W.HWND]
u.GetClassNameW.argtypes = [W.HWND, W.LPWSTR, ctypes.c_int]
u.GetWindowTextW.argtypes = [W.HWND, W.LPWSTR, ctypes.c_int]
u.GetWindowRect.argtypes = [W.HWND, ctypes.POINTER(W.RECT)]


def hval(h):
    return int(h or 0)


def pid_of(hwnd):
    p = W.DWORD(0)
    u.GetWindowThreadProcessId(hwnd, ctypes.byref(p))
    return p.value


def title_of(hwnd):
    b = ctypes.create_unicode_buffer(512)
    u.GetWindowTextW(hwnd, b, 512)
    return b.value


def class_of(hwnd):
    b = ctypes.create_unicode_buffer(256)
    u.GetClassNameW(hwnd, b, 256)
    return b.value


def top_windows():
    out = []

    def cb(h, _l):
        out.append(hval(h))
        return True

    u.EnumWindows(WNDENUMPROC(cb), 0)
    return out


def find_window(pid=None, title=None, cls=None, visible=True):
    for h in top_windows():
        if visible and not u.IsWindowVisible(h):
            continue
        if pid is not None and pid_of(h) != pid:
            continue
        if title is not None and title not in title_of(h):
            continue
        if cls is not None and class_of(h) != cls:
            continue
        return h
    return 0


def describe(h):
    r = W.RECT()
    u.GetWindowRect(h, ctypes.byref(r))
    return {"hwnd": h, "pid": pid_of(h), "title": title_of(h), "class": class_of(h), "rect": [r.left, r.top, r.right, r.bottom]}


def foreground():
    return hval(u.GetForegroundWindow())


def cursor():
    p = W.POINT()
    u.GetCursorPos(ctypes.byref(p))
    return (p.x, p.y)


def clip_seq():
    return u.GetClipboardSequenceNumber()


def lock_timeout():
    v = W.DWORD(0)
    u.SystemParametersInfoW(SPI_GETFOREGROUNDLOCKTIMEOUT, 0, ctypes.byref(v), 0)
    return v.value


def session_id():
    s = W.DWORD(0)
    k32.ProcessIdToSessionId(k32.GetCurrentProcessId(), ctypes.byref(s))
    return s.value


def owned_above(sentinel, target_pid, limit=2000):
    """True when a visible top-level window of target_pid sits above the sentinel in z-order."""
    h = u.GetWindow(sentinel, GW_HWNDPREV)
    n = 0
    while h and n < limit:
        if u.IsWindowVisible(h) and pid_of(h) == target_pid:
            return True
        h = u.GetWindow(h, GW_HWNDPREV)
        n += 1
    return False


def place(hwnd, x, y, w, h):
    u.SetWindowPos(hwnd, 0, x, y, w, h, SWP_NOACTIVATE | SWP_NOZORDER)


def force_foreground(hwnd):
    """Bench setup only: re-front the sentinel between trials (AttachThreadInput, no keystrokes)."""
    if foreground() == hwnd:
        return True
    cur = k32.GetCurrentThreadId()
    fg = foreground()
    threads = {u.GetWindowThreadProcessId(fg, None) if fg else 0, u.GetWindowThreadProcessId(hwnd, None)} - {0, cur}
    attached = [t for t in threads if u.AttachThreadInput(cur, t, True)]
    u.BringWindowToTop(hwnd)
    u.SetForegroundWindow(hwnd)
    for t in attached:
        u.AttachThreadInput(cur, t, False)
    for _ in range(25):
        if foreground() == hwnd:
            return True
        time.sleep(0.02)
    return foreground() == hwnd


def send(hwnd, msg, wp=0, lp=0, timeout=1000):
    res = ULONG_PTR(0)
    ok = u.SendMessageTimeoutW(hwnd, msg, wp, lp, SMTO_ABORTIFHUNG, timeout, ctypes.byref(res))
    return res.value if ok else None


def edit_child(top):
    """Notepad's editor: classic Edit, or RichEditD2DPT in the WinUI Notepad."""
    for cls in ("Edit", "RichEditD2DPT"):
        h = hval(u.FindWindowExW(top, None, cls, None))
        if h:
            return h
    stack = [top]
    while stack:
        p = stack.pop()
        c = hval(u.FindWindowExW(p, None, None, None))
        while c:
            if class_of(c) in ("Edit", "RichEditD2DPT"):
                return c
            stack.append(c)
            c = hval(u.FindWindowExW(p, c, None, None))
    return 0


def edit_text(h):
    n = send(h, WM_GETTEXTLENGTH) or 0
    buf = ctypes.create_unicode_buffer(n + 2)
    send(h, WM_GETTEXT, n + 1, ctypes.addressof(buf))
    return buf.value


def edit_set(h, text, caret=None):
    buf = ctypes.create_unicode_buffer(text)
    send(h, WM_SETTEXT, 0, ctypes.addressof(buf))
    c = len(text) if caret is None else caret
    send(h, EM_SETSEL, c, c)
    send(h, WM_VSCROLL, SB_TOP, 0)


def edit_sel(h):
    v = send(h, EM_GETSEL) or 0
    return (v & 0xFFFF, (v >> 16) & 0xFFFF)


def edit_first_line(h):
    return send(h, EM_GETFIRSTVISIBLELINE) or 0


class Typer:
    """Simulated user: one 'q' every 200 ms through SendInput (goes to whatever has keyboard focus)."""

    def __init__(self, period=0.2):
        self.period = period
        self.sent = 0
        self.run = False
        self.vk = 0x51
        self.scan = u.MapVirtualKeyW(self.vk, 0)

    def _key(self, up):
        i = INPUT(type=1)
        i.u.ki = KEYBDINPUT(self.vk, self.scan, 0x0002 if up else 0, 0, 0)
        return i

    def _loop(self):
        while self.run:
            arr = (INPUT * 2)(self._key(False), self._key(True))
            if u.SendInput(2, arr, ctypes.sizeof(INPUT)) == 2:
                self.sent += 1
            time.sleep(self.period)

    def start(self):
        self.run = True
        self.thread = threading.Thread(target=self._loop, daemon=True)
        self.thread.start()

    def stop(self):
        self.run = False
        self.thread.join()
        time.sleep(0.1)


class Sampler:
    """Samples every ~4 ms: foreground window, target-above-sentinel, cursor, clipboard sequence."""

    def __init__(self, sentinel, target, target_pid, own_pids=()):
        self.s, self.t, self.tpid = sentinel, target, target_pid
        self.own = set(own_pids)

    def _sample(self):
        fg = foreground()
        return (time.perf_counter(), fg, pid_of(fg) if fg else 0, owned_above(self.s, self.tpid), cursor(), clip_seq())

    def start(self):
        self.base = self._sample()
        self.samples = [self.base]
        self.error = None
        self.run = True
        self.th = threading.Thread(target=self._loop, daemon=True)
        self.th.start()

    def _loop(self):
        try:
            while self.run:
                self.samples.append(self._sample())
                time.sleep(0.004)
        except Exception as error:
            self.error = error

    def stop(self):
        self.run = False
        self.th.join()
        if self.error:
            raise RuntimeError("observer sampling failed") from self.error
        self.samples.append(self._sample())
        b = self.base
        ss = self.samples
        lost = [x for x in ss if x[1] != self.s]
        return {
            "sentinel_lost_focus": bool(lost),
            "lost_ms": round(_dur(ss, lambda x: x[1] != self.s) * 1000, 1),
            "target_activated": any(x[2] == self.tpid for x in ss),
            "target_raised": any(x[3] for x in ss),
            "pointer_moved": any(abs(x[4][0] - b[4][0]) > 1 or abs(x[4][1] - b[4][1]) > 1 for x in ss),
            "pointer_end": list(ss[-1][4]), "pointer_start": list(b[4]),
            "clipboard_changed": any(x[5] != b[5] for x in ss),
            "fg_pids": sorted({x[2] for x in ss}),
            "n_samples": len(ss),
        }


def _dur(ss, pred):
    return sum(b[0] - a[0] for a, b in zip(ss, ss[1:]) if pred(a))