Skip to main content
Glama

Server Configuration

Describes the environment variables required to run the server.

NameRequiredDescriptionDefault

No arguments

Instructions

Guidance the server publishes about itself, which clients place ahead of the tool catalog so the model reads it before choosing anything.

This server publishes no instructions, or was last inspected before Glama recorded them.

Capabilities

Features and capabilities supported by this server

Protocol revision2025-11-25

CapabilityDetails
tools
{}

Tools

Functions exposed to the LLM to take actions

NameDescription
tab_listA

List every open tab in the user's own browser, grouped by window: tab id, title and URL, with the active tab of each window and the focused window marked. Use it to find a tab before tab_switch or tab_read.

tab_switchA

Show a tab in the user's browser: make it the active tab of its window and bring that window to the front. Take the tab id from tab_list.

tab_openA

Open a URL in the user's own browser, in a new tab by default, wait up to 10 seconds for it to load and a moment more for the page to finish rendering, and return the tab id with the outline of what is on screen, as tab_read gives it, so no read is needed before acting on the page.

tab_closeA

Close a tab in the user's browser by its id from tab_list. Close only tabs you opened or were asked to.

tab_readA

Read a page in the user's own browser as a compact outline instead of HTML: headings, visible text, and every visible control on its own line with a ref, role, name and state, e.g. [12] textbox "Email" value="" required or [13] button "Sign in". Open dialogs come first. Pass those refs to tab_click, tab_type, tab_fill, tab_select_option and tab_scroll; to find one control on a long page, tab_find is cheaper. Reading does not move the mouse or switch tabs. Defaults to what is on screen in the active tab; use scope "page" for the whole page, and tab_screenshot when the look of the page matters, or when the outline leaves you unsure what the user sees (a dialog, a canvas, a page that changed unexpectedly).

tab_findA

Find controls and text on a page in the user's browser without reading all of it: returns the lines of the whole page's outline that contain the text, controls with their refs, for example [80] button "Create" for "create". A matching heading comes with the start of the section it titles, indented, so searching for a row or section title gives its controls. Cheaper than tab_read on long pages when you know what you are looking for.

tab_waitA

Wait until a text shows on a page in the user's browser, or with gone until it no longer does: a result that loads after a delay, a loading message going away, or the user finishing a step you asked them to do, such as logging in. Returns the lines that mention the text, with refs, as tab_find does. Does not touch the page.

tab_screenshotA

Take a screenshot of the visible part of a tab in the user's browser, returned as an image attachment. The tab is made active in its window first. Use it when the visual layout matters (charts, images, styling, canvas apps); for text and controls, tab_read is cheaper and gives refs to act on. On a canvas page, click what it shows with tab_click x and y: the result gives the viewport size in CSS pixels to scale image pixels by.

tab_networkA

List the fetch and XHR requests a tab in the user's browser sent, oldest first: method, URL, status and request body, and with includeHeaders the request headers. The response body is not recorded. Use it to learn the API a web app calls: act on the page with tab_click, tab_fill or tab_type, then read what that sent. Credentials are redacted in the browser before a request leaves it: a body field (form, JSON or multipart), query parameter or header named like a token, password, secret, API key or authorization, and any value shaped like a known token, key or Bearer value, shows as [redacted] with its name kept. The extension keeps the latest 200 requests of each tab since it started; a request sent before that, or by a page load rather than a script, is not listed.

tab_clickA

Click an element of a page in the user's browser with the real mouse. The tab is brought to the front, the element is scrolled into view if needed, and the pointer moves onto it and clicks once the page confirms the pointer is over it, so the browser window may sit anywhere on screen. Fails without clicking when something covers the element. Take the ref from tab_read. On a canvas page, click a point instead with x and y, read off tab_screenshot: the page confirms the pointer reached that point before the click. Returns what changed on the page (lines that appeared with +, went with -), or the new screen after a navigation, so a menu or dialog the click opened needs no tab_read; take a tab_screenshot when that leaves you unsure what happened. A download the click starts is saved where the browser's save dialog proposes, and the result names the file.

tab_dragA

Drag in a page of the user's browser with the real mouse: from an element or a point to an element or a point, for drag and drop, sortable lists, sliders, and moving or resizing on a canvas. The tab is brought to the front and the page confirms the pointer is on the start before the button goes down. Both ends must be on screen together. Returns what changed on the page. Take refs from tab_read, points from tab_screenshot.

tab_typeA

Type into a text field of a page in the user's browser with the real mouse and keyboard, or without a ref into whatever has the focus (a canvas app editing text). With a ref the field is clicked to focus it, its content is replaced (or appended to with clear=false), and the text is typed, so the page reacts as it would to the user. With a ref it returns the value the field holds afterwards (hidden for passwords), or with submit what changed on screen; without one it always returns what changed on screen. Take the field's ref from tab_read. For several fields at once use tab_fill; for a native select dropdown use tab_select_option.

tab_fillA

Fill several fields of a form in the user's browser in one call, the way tab_type and tab_select_option do one each: text fields are clicked, cleared and typed into with the real keyboard, native selects are set. Then, with submitRef, the submit button is clicked with the real mouse. Returns what each field holds and what changed on screen after the submit. Stops at the first field that fails.

tab_select_optionA

Choose an option in a native dropdown of a page in the user's browser; tab_read lists its options. The macOS popup of a native select cannot be driven reliably by the mouse, so this sets the option the way the page would and fires its input and change events. Custom dropdowns built from other elements are not native selects: open them with tab_click and click the option. Returns what changed on screen.

tab_pressA

Press a key or shortcut in the user's browser with the real keyboard, after bringing the tab to the front. It goes to whatever has focus there: Escape to close a dialog, Tab to move between fields, Enter to submit, arrows in a list. Returns what changed on screen, or the new screen after a navigation.

tab_scrollA

Scroll a page in the user's browser with the real mouse wheel, over the middle of the page or over an element, and return what is on screen afterwards, in the tab_read format.

macos_mouse_moveA

macOS only. Move the mouse cursor to an absolute position in logical coordinates (macOS points, top-left origin), read off macos_screen_capture or macos_mouse_current_position. Inside the browser, tab_click targets page elements exactly instead. Requires Accessibility permission.

macos_mouse_clickA

macOS only. Click the mouse at its current position. Covers left/right/middle click and double-click via arguments (button, doubleClick, modifiers), so this one tool handles regular click, right-click, double-click and modifier clicks. Move the cursor first with macos_mouse_move. Requires Accessibility permission.

macos_mouse_current_positionA

macOS only. Read the mouse cursor's current absolute position in logical coordinates (macOS points, top-left origin) without moving it. Use this to confirm a prior macos_mouse_move landed where expected before clicking or dragging. Requires Accessibility permission because it reuses the shared input session.

macos_mouse_dragA

macOS only. Press the mouse button at the current cursor position, drag to an absolute target in logical coordinates, and release. Use for sliders, selections, resizing, drawing and drag-and-drop, optionally through waypoints, with modifiers held, and with pauses after the press and before the release. Position the cursor at the drag start first (macos_mouse_move). Inside a browser tab, tab_drag targets page elements exactly instead. Requires Accessibility permission.

macos_mouse_scrollA

macOS only. Scroll at the current cursor position. Vertical amount is required (positive up, negative down); horizontal is optional. Defaults to line units. Requires Accessibility permission.

macos_keyboard_typeA

macOS only. Type arbitrary text into the focused element. Injects Unicode directly, so it is layout-independent and correctly produces capitals, symbols, accented letters, and emoji. Use this for entering text; use macos_keyboard_press for named keys (Enter, Tab) and shortcuts. Requires Accessibility permission.

macos_keyboard_pressA

macOS only. Press a single named key, optionally as a shortcut chord with modifiers. Use for keys that are not text (Enter, Tab, Escape, arrows, function keys) and for shortcuts like Cmd+S or Cmd+Shift+P. To type words or symbols, use macos_keyboard_type instead. Requires Accessibility permission.

macos_screen_captureA

macOS only. Capture the primary monitor and return the screenshot as an image attachment so you can see the current screen and decide what to do. This is your eyes: call it to inspect the UI before acting with macos_mouse_move/macos_mouse_click, dividing the pixel coordinates you read off it by the reported scale to get logical points. Inside the browser, prefer the tab_* tools, which target page elements exactly. Requires Screen Recording and Accessibility permissions (the shared input session grants both up front).

macos_list_appsA

macOS only. List the running apps that have windows (name, bundle id, process id), marking the frontmost one and the host, the terminal or app this agent runs in, when macOS reports it. Use it to find the name or bundle id macos_focus_app takes. Needs no macOS permission.

macos_focus_appA

macOS only. Bring a running app to the front, switching to the Space its window is on (a full-screen window has a Space of its own), and wait until it is the frontmost app. Omit app to return to the terminal this agent runs in: do that when a stretch of work that brought another app forward (the tab_* browser tools, another macos_focus_app) is done, and before asking the user anything, so the conversation is back on their screen. Reports the app that was frontmost before, to pass back later. Needs no macOS permission.

Prompts

Interactive templates invoked by user choice

NameDescription

No prompts

Resources

Contextual data attached and managed by the client

NameDescription

No resources

TDQS

A4.1/5.0

Scored across 26 tools

Disambiguation4/5

Nearly every tool targets a distinct action, and the descriptions actively steer between the risky pairs (tab_click vs macos_mouse_click, tab_drag vs macos_mouse_drag, tab_type vs tab_fill vs macos_keyboard_type) by telling the agent to prefer the tab_* tools inside a page. The remaining overlap is structural rather than confusing: a broad browser layer and a generic macOS layer necessarily duplicate input primitives. A couple of fine-grained distinctions (tab_press vs tab_type without a ref, tab_find vs tab_wait) still need the description text to sort out.

Naming Consistency4/5

Names are uniformly snake_case with two clean namespaces, tab_* and macos_*, which is easy to scan and predict. The ordering convention differs slightly between them (tab_ verbs lead, e.g. tab_read/tab_click, while macos_ tools put the object first, e.g. macos_mouse_move, macos_keyboard_press), but each namespace is internally consistent. tab_screenshot and tab_network are noun-style outliers inside an otherwise verb-led prefix.

Tool Count4/5

Twenty-six tools is above the comfortable band, but the server spans two genuinely large surfaces (browser tab automation plus macOS desktop input), so most tools earn their place. Only a few look like thin helpers, notably macos_mouse_current_position, which exists mainly to verify a prior move. It is slightly over-scoped rather than bloated.

Completeness4/5

The browser surface covers the full perceive-act loop (list/read/find/wait/screenshot plus click, type, fill, select, press, scroll, drag) and the macOS surface covers app focus, mouse, keyboard and screen capture, so core workflows have no dead ends. Gaps are real but workable: no back/forward/reload navigation, no file upload, no clipboard access, and network responses cannot be read, only requests. Those are minor omissions an agent can route around rather than blocking failures.

Maintenance

ActivityMaintained
ResponsivenessNo recent community issues