Umbriel

Delete a file, or an EMPTY directory; pass {recursive:true} to delete a directory tree, or {recycle:true} to send it to the Recycle Bin (RECOVERABLE) instead of permanently deleting — recycle is best-effort (a network/removable volume with no Recycle Bin, or an over-quota file, may still hard-delete). Natively, no del/rmdir shell. DESTRUCTIVE — restricted to UMBRIEL_FS_ROOT when set.

Capture the attached window as a compact ref-keyed UIA tree (e.g. Button "Five" [ref=e49#1]). Better than a screenshot for acting; every interactable node carries a [ref=eN#G] you pass VERBATIM to action tools. Refs are valid ONLY until the next re-render — a stale-generation ref is rejected, not mis-resolved. maxNodes (default 1500) bounds a HIGH-DENSITY window — a non-virtualized LOB grid / toolbar / icon-wall with thousands of sibling controls — so the walk stays fast; the tree then ends with "(… more omitted; raise maxNodes …)". maxDepth bounds DEPTH only and does NOT bound a flat (wide) t…

Press-drag-release. By DEFAULT uses the REAL mouse (drag-drop an icon/file, move a slider). {select:true} instead does a CURSOR-FREE drag (text selection / marquee-select) by posting mouse messages to an own-HWND {ref} control (classic Edit/RichEdit/ListView) — but it cannot drag-DROP (for a drop use the real-mouse default). Target raw points {fromX,fromY,toX,toY} or a ref start {ref,toX,toY}. Under UMBRIEL_CURSOR=never the real drag is disabled, but an own-HWND {ref} auto-falls-back to the cursor-free drag-select. For a Ctrl+drag (copy) / Shift+drag (constrain), or a lasso/curve/signature, pa…

Expand a control via the UIA ExpandCollapse pattern — a combobox dropdown, tree node, split button, or menu — cursor-free, no focus (Invoke/posted clicks do NOT open these on WinUI/WPF/Chromium). If the list opens in its OWN window, that popup's hWnd is returned automatically (attach it to select items); otherwise desktop_snapshot to read the revealed items.

Find a desktop control by name/control-type/automationId and act on it (invoke, click, type, setValue, toggle, or read its value).

Find the first screen pixel within tolerance of an RGB color and return its SCREEN-absolute {x,y} — the AHK PixelSearch / nut.js pixelWithColor hole, for color-grounding a surface with no a11y tree. Scope with a region {x,y,width,height}; tolerance is the per-channel ± (default 0). Returns coords to hand to click_point.

Find files recursively by glob under {dir} in ONE call — no `dir /s` / `where` / `Get-ChildItem -Recurse` shell, and no fan-out of list_dir per subdirectory. {pattern} is a glob: "**/*.json" (recursive), "config.*", "src/**/*.ts". Returns matching absolute paths; {includeDirs:true} also MATCHES directories, {limit} caps results (default 200, max 1000). Restricted to UMBRIEL_FS_ROOT when set — every hit is re-validated against the sandbox root and matches that resolve outside it are dropped (counted in a footer).

Template-match an icon/button image on the live screen and return its SCREEN-absolute {x,y,score} — the AHK ImageSearch / nut.js findOnScreen hole, for grounding a game/canvas/WebGL/remote-desktop surface with no a11y tree. Pass {image} as a base64-encoded PNG (8-bit, color type 0/2/3/6); scope with a region {x,y,width,height}; threshold 0..1 (default 0.92); all:true returns every match. Returns coords to hand to click_point. Matches the BitBlt screen (CAPTUREBLT includes overlays), not a WGC live-GPU frame.

Find a substring inside a text/document control and SELECT it — cursor-free, the desktop analog of getByText. Target the Document/Edit ref; the match becomes the active text selection so you can then copy it, replace just that match (type or paste over it — NOT set_value, which overwrites the WHOLE control), or read it. Returns the matched text, or "not found".

Move keyboard focus to a control by ref (UIA SetFocus) — CURSOR-FREE, even for a WinUI/WPF/Electron sub-control with NO own window handle. A subsequent press_key chord / Tab / arrow then lands on the focused control via SendInput (under UMBRIEL_CURSOR=never a no-own-HWND control has NO key path — drive it by intent: invoke / select / set_value instead). Prefer invoke/set_value/toggle when a pattern exists.

Enumerate the live display configuration natively (no WMI/PowerShell): each attached monitor's device + adapter name, current resolution (W×H), refresh rate (Hz), color depth (bpp), and which is primary. Useful before moving/sizing a window (does it fit on its monitor?), choosing which monitor to screenshot, or reasoning about a multi-monitor layout.

Read an environment variable, or list all, in a scope: {scope:"process"} (this server's live env), "user" (HKCU\Environment — persists for your account), "machine" (HKLM — system-wide). Give {name} for one, omit it to list every variable in the scope. Natively — no set/echo shell.

Return the desktop element that currently has keyboard focus (role, name, automationId, bounds).

Act on a single data-grid cell by (row, column) — the editable-grid path read_table (read-only) cannot reach. Target the GridPattern container ref (the List/DataGrid/Table node, same as read_table), give 0-based row+column, and a verb: read (default), set_value, invoke, toggle, select, click. Cursor-free (UIA pattern on the cell). Use read_table first to see the extent + which column is which.

Press and hold a key for durationMs, then release (e.g. an arrow-repeat or a game key). With a ref to a control that has its OWN window handle, the hold is posted cursor-free (a WM_KEYDOWN autorepeat stream); without a ref (or for a sub-control with no own HWND) it uses SendInput to the focused window.

Move the REAL mouse pointer onto a control (by {ref}) or a raw {x,y} and leave it there WITHOUT clicking — the Playwright locator.hover() / page.mouse.move() analogue. The only way to reveal hover-only UI: a tooltip that renders on WM_MOUSEMOVE, a hover-expand submenu/flyout, a hover-revealed row/tab button, or a hover-state to screenshot. Moves the real cursor (SetCursorPos), so it is NOT cursor-free and is refused under UMBRIEL_CURSOR=never. After hovering, desktop_snapshot or screenshot to see what appeared.

Dump the full live state of one ref: role, name, automationId, className, bounds, enabled, value, toggle/expand/selected/range/scroll state, clickable point, native window handle, TextPattern body, and a "can:" list of the actions the control actually supports (invoke/set_value/toggle/expand/collapse/select/scroll/read-text/read-table) — pick the verb from that list instead of guessing from the role, since a Button may only expand and invoke can silently no-op. A password field is shown as "(password)" with its value withheld. Read state without round-tripping through the tree.

Identify the UIA control at a screen pixel (role, name, automationId, className, bounds) — turn a pixel from screen_capture into a ground-truth control. Coordinates are virtual-screen absolute.

Invoke a control via the UIA Invoke pattern (buttons, links) — cursor-free. If it opens a flyout/menu in its OWN window, that popup's hWnd is returned automatically — attach it to drive its items.

Invoke a control in a Java Swing/AWT window by its name — push button, check box, radio button, menu item, or JList item (a list row is SELECTED by invoking it) — cursor-free / background via the Java Access Bridge (doAccessibleActions). Call java_tree FIRST for exact names. Targets the first AccessibleName match; narrow by {role} (en_US role substring, e.g. "check box") when names collide — if name AND role both collide, use click_point at the node's java_tree bounds center. CAVEAT: a JComboBox / JTree item may report success WITHOUT changing the selection — confirm via the appended tree's "s…

Set the contents of a Java Swing/AWT text control by its name — cursor-free / background via the Java Access Bridge (setTextContents; replaces the whole value, no cursor / foreground / focus change). Call java_tree FIRST to get exact names. Targets the first match; optionally narrow by {role}. Returns whether it succeeded and appends the resulting java tree (the supplied text is not echoed back).

The Java Access Bridge accessibility tree (role/name/states/bounds) of a Java Swing/AWT (and JAB-bridged JavaFX) window — a SunAwtFrame/SunAwtDialog exposes NOTHING to UIA or MSAA (only its bare frame), but the JVM speaks the Access Bridge; cursor-free / background. To ACT on a node by its name use java_invoke (buttons / checkboxes / menu items) or java_set_text (text fields); click_point at a node's bounds center is the pixel fallback. Returns null with a hint if the window is not a bridge-visible Java window (the JVM needs the Access Bridge: `jabswitch -enable`, or launch with -Djavax.access…

Terminate a process by {pid} (precise) or {name} — an EXACT case-insensitive image name that terminates EVERY process with that exact name (e.g. "chrome.exe" kills all Chrome). A substring is NOT accepted, so a stray short name cannot mass-kill; this server and its host process are never targeted. Reports killed / access-denied (elevated/protected — see current_user) / not-found. No taskkill/Stop-Process. Destructive.

Start a program by name (notepad, calc) OR an App-Paths / Store-alias exe a bare $PATH spawn can't find (mspaint, winword, excel, wt) — it falls back to ShellExecuteW automatically. With a title/className, waits for the NEWLY-appeared window THIS launch created (ignoring same-titled windows already open, preferring the spawned pid) and attaches (returns a snapshot); otherwise just spawns it. To gate on / attach to an ALREADY-open window use wait_for_window.

List network adapters natively (no ipconfig / Get-NetAdapter shell) — each NIC's friendly name, type (ethernet/wifi/loopback/tunnel/…), up/down status, MAC, MTU, and all assigned IPv4/IPv6 addresses. A real diagnostic read of the machine's network configuration.

List active TCP connections + listeners (and UDP endpoints) natively (no netstat -ano / Get-NetTCPConnection shell) — each row's protocol, state (LISTEN/ESTABLISHED/…), local and remote address:port, and the OWNING pid. Tie a pid to its process with process_info. IPv4. Optional {udp:false} to skip UDP, {state} (e.g. "LISTEN") and {pid} filters; {limit} caps output (default 200).

List a directory (names + dir/file kind). Restricted to UMBRIEL_FS_ROOT when set.

List Windows Defender Firewall rules natively (no netsh advfirewall firewall show rule) — what inbound/outbound traffic is allowed or blocked: each rule's name, direction (in/out), action (allow/block), enabled state, protocol (tcp/udp/…), and local ports. A real security/diagnostic read. Optional {direction} (in|out), {enabledOnly}, and {match} (case-insensitive substring of the rule name) filters; {limit} caps the output (default 60, newest-first by enumeration order).

List a process's loaded modules (the .exe + every DLL) by {pid} — the Process Explorer "DLLs" view (no tasklist /m / Get-Process -Module / listdlls shell): each module's base name, load address, mapped size, and full on-disk path. Diagnose DLL injection, a version mismatch, or which .dll backs a stuck process; pair with process_info / list_processes to pick the pid. Returns empty for a dead pid or an elevated/protected process (the same graceful-deny as process_info).

List the physical monitors (index, full bounds, work area, primary flag) — the geometry an agent needs to place windows or pick a region to screen_capture.

List running processes as {processId, name} (optionally filtered by an image-name substring). Pair with wait_for_process / launch_app / attach by process.

List Windows scheduled tasks natively (no schtasks/Get-ScheduledTask shell) — THE #1 autorun/persistence surface: what runs on a schedule or at logon, when each last ran (+ its result code) and runs next, and whether it is enabled. Recursively walks every task folder; hidden tasks included. Optional {folder} prefix filter (e.g. "\\Microsoft\\Windows") and {enabledOnly}.

List every Windows service (name, display name, current state: running/stopped/start-pending/…) natively — no sc query / Get-Service shell. The discovery half of service control; use control_service for a specific service's owning pid and to start/stop it.

List a container's view modes (UIA MultipleViewPattern) — e.g. File Explorer's Items View: current + supported {id, name} like Details/List/Large icons/Tiles/Content. Target the ref of the List/DataGrid/items container. Empty if the control has no MultipleView pattern.

List the mounted drives natively (no wmic logicaldisk / Get-Volume / Get-PSDrive shell): each drive root with its type (fixed/removable/network/cd-rom/ram-disk), volume label, filesystem (NTFS/FAT32/exFAT), and total + free space. Answer "will this install fit", "why is the disk full", or "what drives are mounted" before a copy/write/cleanup. An empty optical/card reader reports its type only (not ready). Read-only.

List visible top-level windows (title, className, processId, exe, hWnd, minimized/maximized/foreground, integrity). Start here. A visible toast/notification popup is appended as an attachable "notification" row (hWnd) — EnumWindows never returns it, so attach it by hWnd to read its text + invoke its Dismiss/Settings/action buttons. Set includePopups:true to ALSO list untitled popups — a combobox dropdown, classic #32768 context menu, or WPF/WinUI Popup opens in its own untitled window; list it, then attach it by hWnd to see + invoke its items.

Create a directory (and any missing parents) natively, no mkdir shell. Restricted to UMBRIEL_FS_ROOT when set.

Move/resize/rotate an ELEMENT (by {ref}) cursor-free via UIA TransformPattern — the FlaUI Transform-pattern parity tool. Unlike manage_window (which SetWindowPos a top-level HWND), this reaches an HWND-less child: an MDI child, a dockable/floating pane, a resizable splitter panel. move needs x,y; resize needs width,height; rotate needs degrees. Check inspect_element first — only an element whose can: list shows move/resize/rotate supports it (it throws otherwise). Works locked/background, no real cursor.

Control a live process by {pid} WITHOUT killing it (no pssuspend/PowerShell): {action:"suspend"} freezes EVERY thread (pause a runaway/installer to inspect, or let the foreground recover), {action:"resume"} thaws it, {action:"priority", priority} renices it (drop a CPU hog to idle, or raise a stalled job). Never targets this server or its host. Reports the threads acted on / access-denied (elevated/protected — see current_user) / not-found. Destructive.

Create/update or delete a Windows scheduled task natively (no schtasks /create|/delete, no Register/Unregister-ScheduledTask shell). {action:"create"} registers (or updates) a task in the root folder under {name} from a task-definition {xml} string — the XML carries the trigger(s)/action(s)/principal, so it drives ANY schedule (at logon, daily, on-idle, …); generate it in the Task Scheduler schema. {action:"delete"} removes the task by {name}. Runs as the current interactive user. REQUIRES {confirm:true} — a task is an autorun/persistence entry. Destructive.

Move/minimize/maximize/restore/raise/snap/topmost/untopmost/set_opacity/close a window WITHOUT activating it (works on a background window; raise is a best-effort z-order restack, not a true bring-to-front). move repositions AND resizes in one call (needs x,y,width,height — there is no separate resize action). snap needs edge (left/right/top/bottom half, or center) — tiles the window on its monitor cursor-free, no Win+arrow. topmost pins the window into the always-on-top band (untopmost releases it) — a persistent z-order a one-shot raise cannot give. set_opacity needs alpha 0–255 (layered-win…

Move/rename a file or directory from {from} to {to} natively (rename, or copy+delete across volumes), no move shell. Refuses if {to} already exists unless {overwrite:true}. Both paths restricted to UMBRIEL_FS_ROOT when set.

The MSAA (oleacc IAccessible) tree of a window — the legacy fallback for owner-draw apps that expose no useful UIA tree.

The raw native Win32 window hierarchy (HWND class, control id, WS_*/WS_EX_* styles, rect) — the Spy++ view, for classic-Win32 / owner-draw windows where the UIA tree is sparse. Reads any window, foreground or not.

READ TEXT out of the raw PIXELS of one control (pass `ref` — OCCLUSION-CORRECT, just that <canvas>/chart/custom control), the attached window, a given hWnd, or a screen region, via Windows OCR — for surfaces with NO accessibility tree: a <canvas>/WebGL app, a game, a video frame, a remote-desktop session, a chart, a scanned document, an image. Captures even occluded/GPU/background windows (WGC). Returns each line with a SCREEN-pixel bounding box; click recognized text with click_point at a box centre.

Open a file, folder, or URL with its default handler (Explorer/browser).

Paste text via the clipboard — the reliable large-text path. With a ref whose control has its own window handle it is cursor-free (sets the clipboard, then WM_PASTE); otherwise it focuses + Ctrl+V via SendInput. Omit text to paste the current clipboard. Prefer set_value when the control supports the Value pattern.

Drive the Windows session/power state natively (no shutdown.exe / logoff / rundll32 user32,LockWorkStation|powrprof,SetSuspendState / PowerShell Stop-Computer|Restart-Computer). {action}: "lock" locks the workstation (reversible, no data loss); "logoff" signs the current user out; "restart" reboots; "shutdown" powers off; "sleep" suspends to RAM; "hibernate" suspends to disk. restart/shutdown are PLANNED + non-forced (apps are asked to close, not killed); restart/shutdown/sleep/hibernate self-enable the shutdown privilege (no elevation for the user's own session). REQUIRES {confirm:true} — loc…

Send a key or chord, e.g. "Enter", "Control+S", "Control+Shift+Tab", "F4". With a ref AND a single key (no chord), posts the key to that control cursor-free. On an own-HWND control the everyday edit chords are ALSO cursor-free — Control+A/C/X/V/Z map to posted EM_SETSEL/WM_COPY/WM_CUT/WM_PASTE/EM_UNDO. Any other chord with a ref FOCUSES it first (cursor-free UIA SetFocus) then sends synthetic input. With no ref, the key/chord goes to whatever currently holds focus.

Deep detail for ONE process by {pid} (no tasklist/Get-Process/wmic): name, parent pid, start time, CPU kernel/user ms, working-set + peak MB, open handle count, the on-disk image path (which binary it really is — disambiguates two same-named processes), the COMMAND LINE it was launched with and its current working directory (the forensic detail otherwise only via wmic/Get-CimInstance Win32_Process — read from the PEB), and the child process list — so you can pick WHICH pid to kill/suspend/reprioritize (the runaway renderer, the leaking child) instead of guessing from the flat list_processes na…

Read the Windows clipboard. Returns text (pairs with copy/Ctrl+C to pull selected text from any app, even one with no a11y tree); if it holds copied FILES (Explorer Ctrl+C/Cut → CF_HDROP) lists their full paths; if it holds an IMAGE (CF_DIB — a screenshot / copied picture) and no text, returns the image itself.

Read the newest records from a Windows event log natively (no Get-WinEvent/wevtutil shell) — THE canonical record of crashes, service failures, driver faults, and unexpected shutdowns; answer "why did X crash / what failed last night". {log} ∈ System|Application|Security|Setup (default System), {count} newest (default 20, max 100), {level} ∈ error|warning|all (default all). Each record: time, type, source, event id, and the raw insertion strings. System/Application read without elevation; Security needs admin.

Read a text file (first 20k chars). Restricted to UMBRIEL_FS_ROOT when set.

Read a data grid / list / table (Explorer details view, a DataGrid, a spreadsheet-like control) as structured rows — UIA GridPattern cell-by-cell, with column headers when available. Target a ref from the latest snapshot (the List/DataGrid/Table node). Returns a markdown table; far cheaper and more reliable than reading cells from a screenshot. For a grid bigger than maxRows, PAGE forward with startRow (the footer names the next startRow) instead of re-reading from the top. To ACT on one cell (edit/toggle/invoke/select it), use grid_cell {ref, row, column, do}.

Serialize the target window accessibility tree to JSON (role, name, automationId, bounds) for grounding actions.

Read ONE Windows registry value natively (no reg query / Get-ItemProperty shell): an install path, an OS/app version, a policy or HKCU preference. {hive} ∈ HKLM|HKCU|HKCR|HKU, {key} the backslash-separated subkey path, {value} the value name (omit for the key default). Returns the typed value (REG_SZ/DWORD/QWORD/MULTI_SZ/BINARY decoded).

Create or delete a registry KEY natively (no reg add/reg delete/New-Item/Remove-Item shell) — the half registry_set lacks: seed a new HKCU\Software\<App> config subtree BEFORE registry_set can write a value into it, or remove an app/policy key. {hive} ∈ HKLM|HKCU|HKCR|HKU, {key} the backslash-separated subkey path, {action} ∈ create|delete. create makes the key AND any missing parent keys (idempotent — reports created vs already-existed). delete removes the key; a bare delete refuses a key that still has subkeys, so pass {recursive:true} to delete the whole subtree. REQUIRES {confirm:true} — a…

Enumerate a Windows registry key natively (no reg query shell): its immediate subkeys and its values (name / type / decoded data). {hive} ∈ HKLM|HKCU|HKCR|HKU, {key} the backslash-separated subkey path.

Write or delete ONE registry value on an EXISTING key (no reg add/Set-ItemProperty shell) — configure an app/policy/preference outside env vars (e.g. show file extensions, seed an app setting). {hive} ∈ HKLM|HKCU|HKCR|HKU, {key} the subkey path, {value} the value name (omit for the key default), {type} ∈ REG_SZ|REG_EXPAND_SZ|REG_DWORD|REG_QWORD|REG_MULTI_SZ, {data} (string for SZ, integer for DWORD/QWORD, string[] for MULTI_SZ), or {delete:true}. REQUIRES {confirm:true} — a wrong write can corrupt the machine or an app. The key must already exist; HKLM/protected keys need elevation (clean acce…

Scroll a VIRTUALIZED / off-screen list, grid, or tree item into view by selector, then optionally act on it. Use when a desktop_snapshot omits an item because it is scrolled out of view (Explorer folders, long lists, data grids, horizontal carousels) — those rows are not in the a11y tree until realized. Scans the container vertically (primary), then horizontally when it only scrolls sideways. Cursor-free. do = invoke|click|focus|type|set_value|toggle|select|read; omit do to just bring it into the next snapshot (it then has a ref). For do:select, mode:add multi-selects (keeps existing) and mode…

Run a console command and return its exit code, stdout, and stderr. For programs that exit on their own (CLI tools). NOT for GUI apps or servers that keep running — those are killed after timeoutMs (default 30000) and you get partial output; launch GUI apps with launch_app instead.

Capture the WHOLE virtual desktop (all monitors) or a region as a PNG via BitBlt+CAPTUREBLT — the only path that sees a 2nd monitor, a game/canvas/WebGL surface, DWM-composited or overlay output, or anything with no window attached. Omit the region for the full desktop.

Capture the attached window as a PNG. Tries PrintWindow, then Windows.Graphics.Capture (sees occluded/background/GPU-composited content) when PrintWindow renders blank, then a desktop-region grab. For the whole desktop or a 2nd monitor use screen_capture; for a specific occluded window by ref/hWnd use capture_window.

Capture the attached window as a Set-of-Marks PNG: numbered red boxes drawn over every interactable control (derived from ground-truth UIA bounds, not a vision guess) plus a legend mapping each number to its ref/role/name. Marks are window-local; blank on a locked session (PrintWindow).

Scroll a control (cursor-free). direction up/down/left/right scrolls the nearest usable ScrollPattern container by `amount` small steps; with NO usable ScrollPattern it posts a wheel — to a ScrollPattern-less own-HWND control (ListView/Edit/TreeView), OR a Chromium/Electron web page whose ScrollPattern FALSELY reports not-scrollable (wheel goes to the page's browser host window — this is how you scroll a browser/VS Code/Discord page). top/bottom jump to start/end, page-up/down/left/right move one page (×`amount`) — these need a GENUINELY scrollable ScrollPattern (a Chromium page is refused; us…

Select a list/grid/tree item via the UIA SelectionItem pattern — cursor-free on WinUI/WPF/Chromium items; a classic MSAA-bridged own-HWND item (radio/list-item/tab/cell) routes through the provider bridge and moves foreground to that control’s window (disclosed in the result). mode: replace (default, clears other selections), add (multi-select — keeps the others), remove (deselect). The returned snapshot marks selected refs (selected).

Pick a value from a combobox / dropdown / list / tree by its visible TEXT in ONE call (Playwright selectOption({label}), FlaUI comboBox.Select(value)) — cursor-free on WinUI/WPF/Chromium items; a classic MSAA-bridged own-HWND item routes through the provider bridge and moves foreground to that control’s window (disclosed in the result). Target the COMBO/LIST ref (not an item): it expands if needed, scroll-reveals the matching item even when virtualized, selects it (SelectionItem, Invoke fallback), then collapses. ignoreCase matches the text case-insensitively. Errors if no item matches.

Set the Windows clipboard text (does not paste).

Change a monitor's mode natively (no Settings UI / WMI / PowerShell) — the symmetric WRITE half of get_displays, focus-free + BG-default. {device} is a get_displays device name (e.g. "\\.\DISPLAY1"); set any of {width}/{height} (resolution), {orientation} (0|90|180|270 degrees), {refreshHz}. The mode is VALIDATED (CDS_TEST) before applying and applied DYNAMICALLY by default — Windows auto-reverts a bad mode after its confirm-timeout, so no permanent black screen; pass {persist:true} to write it to the registry. A rotation usually needs matching {width}/{height} (a portrait mode wants the dimen…

Set or delete an environment variable in a scope (no setx/reg/PowerShell). {scope:"user"} writes HKCU\Environment + broadcasts WM_SETTINGCHANGE so it PERSISTS across reboots and new processes inherit it (set JAVA_HOME, add to PATH); "machine" writes HKLM (needs elevation → clean access-denied); "process" is transient (this server + its children). Pass {value} to set, or {delete:true} to remove. Destructive.

Set a control value in one call — no keystrokes, FOCUS-CLEAN on a background/minimized/locked window. For a classic Win32/HWND text field it posts WM_SETTEXT (the raw UIA Value pattern would STEAL FOREGROUND to the control via the MSAA bridge, so this tool posts instead); a WinUI/WPF/Electron sub-control with no own HWND uses the UIA Value pattern (which activates it). A numeric value on a slider/spinner sets it via the RangeValue pattern.

Switch a container to a view mode CURSOR-FREE (UIA MultipleViewPattern.SetCurrentView) — e.g. flip File Explorer to Details to make read_table work. Pass a view `id` from list_views. No focus, no cursor, works on a background window.

Stat a path natively (no dir/Get-Item shell): whether it exists, file vs directory, byte size, modified + created times, and the Windows attribute flags (read-only / hidden / system / reparse-point). Check a file's size BEFORE read_file (which caps at 20k chars). Restricted to UMBRIEL_FS_ROOT when set.

System resource usage — total/available RAM + memory-load %, system-wide CPU % (sampled over a short interval), uptime, and the running-process count. Answer "how much memory / CPU are we using?" natively, no shell. Read-only; works on a background/locked desktop.

Report the environment signals that decide whether a read or capture is TRUSTWORTHY: a lock screen / UAC secure desktop (the user's apps are NOT readable or drivable until it clears), a running screensaver (display blanked), a headless 0-monitor or RDP session, AC vs battery, and the foreground window. Check this FIRST when a snapshot/capture comes back empty or a screenshot looks blank — do not conclude a control is "missing" if the desktop is actually locked, screensaved, or has no display.

Toggle a checkbox or toggle button via the UIA Toggle pattern (cursor-free). Pass {state:true|false} to SET a known state idempotently (no flip if already there) instead of blindly flipping — one call, no inspect-then-branch.

Enter text in an editable control. Own-HWND controls use cursor-free WM_CHAR. WinUI/WPF/Chromium editors get a verified foreground lease for SendInput, then the previous window is restored by default. For controlled message editors such as Discord/Slate use method:"paste", verify:true, submit:true; verification refuses an unconfirmed send instead of inviting a duplicate retry. Search fields retain their query after Enter, so type them with submit:false, then press_key Enter and verify the results separately. clear:true replaces existing text.

Wait until a control matching the selector APPEARS in the attached window (or, with gone:true, until it DISAPPEARS — the spinner / "Loading…" / progress-bar / just-dismissed-modal gate), then return a fresh snapshot. Pass state to instead retry until the match reaches a STATE (toggle on, value stuck, selected/expanded/enabled) — the desktop expect(locator).toBeChecked()/toHaveValue(), so you confirm an action landed without hand-rolling snapshot → parse → sleep → re-snapshot. Target by selector, or by {ref, state} to await the EXACT control a ref denotes — the only way to wait on a control tha…

Wait for the NEXT transient accessibility ANNOUNCEMENT — a modal dialog, an alert, or a live-region (aria-live) update — that leaves no window and no stable tree node (an in-app "Saved"/error status, a form-validation message, a modal that auto-dismisses), then return its {type, text, hWnd, processId}. Driven by SetWinEventHook (EVENT_SYSTEM_ALERT / DIALOGSTART / OBJECT_LIVEREGIONCHANGED) on the safe posted-message pump — the screen-reader-grade signal a re-snapshot+diff misses. Answers "did my action raise an error/confirmation?". Filter by {type} (alert|dialog|liveRegion), {text} (substring)…

Wait until a process whose image name contains the given text is running (e.g. "chrome.exe"), then return its pid. Resolves immediately if already running. Use to trigger work the moment a process the agent is waiting on spawns. Pass {gone:true} to instead wait until every matching process has EXITED (an installer / build / conversion / launched app FINISHING) — the right gate for a windowless job, where wait_for_window {gone} would falsely resolve at once. Pass {attach:true} to attach to the process's window and return its snapshot in ONE call (like launch_app) — falls back to the pid + a ste…

Wait until a top-level window matching title (substring) / className / process appears ANYWHERE on the desktop — driven by a SetWinEventHook event hook, not polling — then return its title/className/processId/hWnd. Resolves immediately if one is already open. Use to gate on a dialog, a just-launched app, or a page finishing navigation. Omit all fields to wait for any new window. Pass {attach:true} to attach to the matched window and return its snapshot in ONE call (like launch_app) — the common gate-then-drive loop without a follow-up attach. Pass {gone:true} to instead wait until a matching w…

Block until the attached window stops changing (its tree is stable for quietMs), then return a fresh snapshot. Use after an action that triggers async rendering; pair with wait_for_window when you are waiting on a NEW window rather than the current one settling.

Probe whether a window is RESPONSIVE (its UI thread pumps messages) or HUNG/frozen — a WM_NULL ping via SendMessageTimeout, no foreground steal, no input. Unlike wait_idle (which reports a FROZEN window as "settled" because its tree stops changing), this catches a genuinely hung app, so you can escalate (manage_process suspend / kill_process / power_state) instead of waiting forever, or gate input on real readiness after a launch/heavy action. Targets the explicit {hWnd}, a {ref}'s window, or the attached window.

Block until the PIXELS stop changing — the visual analog of wait_idle for a surface with no a11y tree (a game/canvas/WebGL/video/GPU-composited browser view), where wait_idle returns "settled" instantly because the UIA tree never moves. Polls the window (occlusion-correct WGC via {hWnd}/{ref} or the attached window) or a screen {x,y,width,height} region (FG BitBlt), comparing consecutive frames; settles when the mean per-channel RGB delta stays within tolerance for quietMs. Returns "settled" or "still animating at timeout".

Write a text file (overwrites). Restricted to UMBRIEL_FS_ROOT when set.