Hyprland Computer Use

Press a key/chord (e.g. 'ctrl+s', 'Return', 'alt+Tab'). If con_id (address) is given, focus it first and fail if that focus can't be verified.

Launch an app via Hyprland's exec dispatcher. Opens on the current workspace — pair with goto_workspace or move_window_to_workspace to place it.

Send a message to the active layout engine (dwindle/master), e.g. 'togglesplit', 'swapsplit', 'orientationnext'. (Hyprland has no per-window splith/tabbed/stacking like i3.)

List all Hyprland windows: id (address), class, title, workspace, output, global geometry, floating/focus/visibility. Use the `id` for focus/screenshot.

Move the pointer to (x,y) in screenshot `frame_id`'s pixel space. follow=True mimics a physical mouse's hover-focus: after moving, give keyboard focus to the window under the cursor. The synthetic pointer alone does NOT trigger Hyprland's own follow_mouse on a warp, so focus is set explicitly. No-op focus if the cursor lands on empty space or a bar. (A plain click already focuses what it hits — use follow to focus by hovering, without clicking.)

Move a window (by address) to a workspace without following it.

Read the text of a Wayland selection: 'clipboard' (Ctrl-C / Ctrl-Shift-V) or 'primary' (select / middle-click). Returns '' if empty.

Escape hatch: run a raw Hyprland dispatcher as the Lua expression passed to hl.dispatch(...), e.g. 'hl.dsp.window.fullscreen({})' or 'hl.dsp.window.move({ direction = "l" })'. `exit` is blocked.

Screenshot one output (monitor); defaults to the focused output. Pass an output name from get_outputs (e.g. "DP-1") to target another monitor. Returns the image plus a frame_id — pass that frame_id to click/move/etc.

Full-resolution screenshot cropped to a single window (by address). NOTE: this crops the layout grab by the window's *geometry*. The window must be on its monitor's active workspace (else the region shows whatever IS there); a floating window sitting on top can also occlude it. A warning is added to the caption when the window isn't focused.

Scroll at (x,y) (screenshot `frame_id` pixel space). direction: up|down.

Enable/disable floating for a window (by address).

List all tasks with their state (running | done+exit_code) as JSON — the copilot tmux sessions started via task_start (plain tmux sessions excluded).

Send input to a running task — e.g. answer a prompt it's blocked on. Default types `text` + Enter; enter=False sends interpreted keys ('C-c', 'Up', 'Escape') for control sequences. (Detecting that a task is waiting on input is best-effort: read task_status's tail and answer accordingly.)

Launch `command` as a background TASK in a hidden copilot tmux session — no window, no focus, zero screen footprint. The command is wrapped so completion is detectable (a `__TASK_DONE__:<exit_code>` sentinel), so you can poll it with task_status. Returns the task's initial {name, state} as JSON. Names must be unique and free of ':', '.', '/', and whitespace.

Check a task: JSON {name, state, exit_code?, tail}. state is 'running' (still going), 'done' (finished — `exit_code` 0 = success, non-zero = failure), or 'missing' (no such task). `tail` = that many last lines of its output.

Stop a task by killing its hidden tmux session (only touches the isolated 'hypr-cua' copilot socket).

Send interpreted tmux keys to `target` (e.g. 'C-c' to interrupt, 'Up', 'Escape', 'q') — for TUIs / control sequences, not literal command text.

Kill copilot session `target` (only touches the isolated 'hypr-cua' socket).

List the copilot's tmux panes — session, pane, running command, size, state. They live on a dedicated 'hypr-cua' tmux socket, isolated from your real (default-socket) sessions. Detached = no window, no focus, zero screen footprint — the way to run terminal work on a non-visible workspace.

Create a detached copilot session `name` running a shell (or `command`). No window, no focus. Drive it with tmux_run/tmux_keys, read it with tmux_read.

Capture session `target`'s terminal text (last `lines` incl. scrollback).

Type a shell command line into session `target` and press Enter. Read the output afterward with tmux_read (the shell persists between calls).

Type text into the focused window. If con_id (address) is given, focus it first and fail (no keystrokes sent) if that focus can't be verified. NOTE: US-ASCII only (uinput has no unicode-compose path); unmapped characters are skipped, and embedded newlines are Enter keypresses.

Set a Wayland selection ('clipboard' or 'primary') to text, then paste with key('ctrl+v' or 'ctrl+shift+v') or a middle-click. Returns only a length summary — never the value. secret=True marks the value for redaction in this server's action log (not built yet) and keeps it out of the return; the text still transits this tool call, so it appears in the MCP client's transcript.