Skip to main content
Glama

record

Record a web app headlessly, upload it as a Clipy recording, and return the share link and agent-context URL for immediate sharing and playback.

Instructions

Record a web app HEADLESSLY and upload it as a Clipy recording, then return its share link + agent-context URL. Use this to capture the outcome of work you just did — e.g. after building a feature, record the running app so it can be shared or read back. Opens the given URL in a headless Chromium (works in cloud sandboxes, no display needed), records for durationSeconds, and streams the video into Clipy's pipeline. Set type so the summary reads the recording correctly, viewports to sweep multiple screen sizes into one video, and storageState/initScript/userDataDir to record behind a login. Requires (1) Playwright installed in this MCP server's environment (npm i -g playwright && npx playwright install chromium) and (2) the CLIPY_API_KEY to carry the 'ingest' scope. Recording the REAL Mac screen or a window's initial screen area (ScreenCaptureKit, real logged-in browser) is CLI-only — clipy record --source mac-screen --window "<app>" — and not available via MCP. Quick per-cookie / per-localStorage-key injection (the CLI's --cookie / --local-storage) is a CLI-only convenience; storageState covers the same need here. The result reports the RESOLVED capture source (source: the post-redirect URL, page title and viewport actually being recorded) — compare it against the surface your driver is acting on BEFORE doing minutes of work, because Clipy will never focus or foreground a window or tab for you. Auth note: storageState seeds exactly what it contains (cookies + localStorage) but can't reproduce a whole browser identity (IndexedDB, service workers, some cross-origin auth); for those, produce a storageState via an interactive npx playwright open --save-storage=state.json <login-url> first, or use userDataDir pointed at a DEDICATED (never live) profile directory. After it returns, call wait_for_artifacts then get_agent_context to read the transcript/summary.

Input Schema

TableJSON Schema
NameRequiredDescriptionDefault
urlYesThe http(s) URL to open and record (e.g. http://localhost:3000).
nameNoOptional title for the recording.
typeNoWhat the recording IS, so the AI summary doesn't misread it. One of: bug_report, feature_request, product_demo, walkthrough_tutorial, feedback_review, discussion_talk, other (aliases like bug/feature/demo/tutorial/review/talk accepted).
notesNoTimestamped narration notes describing what the recording shows. Headless captures are silent, so these notes BECOME the recording's transcript — write them like chapters ('0s: homepage loads', '8s: the new export button appears').
widthNoViewport + video width (default 1280). Ignored when `viewports` is set.
heightNoViewport + video height (default 720). Ignored when `viewports` is set.
viewportsNoRecord several screen sizes sequentially into ONE video (for cross-size demos). Comma-separated aliases (mobile,tablet,desktop) or WIDTHxHEIGHT (e.g. '390x844,1440x900'). The frame is sized to the largest; each pass slow-scrolls the page and gets an auto chapter note. When set, width/height are ignored.
initScriptNoPath to a JS file run in the page before every navigation (context.addInitScript) — e.g. to seed localStorage or stub an API. Contents are never logged.
descriptionNoOptional description for the recording.
userDataDirNoPath to a Chromium user-data ROOT — the dir holding 'Local State' plus profile subdirs (macOS Chrome: ~/Library/Application Support/Google/Chrome). WITHOUT profileDirectory, Clipy opens this dir's 'Default' profile directly and writes to it, so it is refused while a live Chrome holds it locked (quit Chrome first). WITH profileDirectory, Clipy COPIES that named profile into a temporary root and records the copy — your real profile is never opened or modified. A profile SUBDIR passed as the root is refused. Mutually exclusive with storageState.
storageStateNoPath to a Playwright storageState JSON (cookies + localStorage) to record behind a login. Passed unchanged to the browser context; its contents are never logged. Mutually exclusive with userDataDir.
durationSecondsNoHow long to record after the page loads, per viewport pass (default 15, max 300).
profileDirectoryNoWhich profile INSIDE userDataDir to record — 'Default', 'Profile 1', 'Profile 2', … (exact folder name from chrome://version → 'Profile Path'). Clipy COPIES that profile into a temporary scratch root (as its Default) and records the copy: your real profile is never opened or modified, and the copy is deleted after upload. The result discloses the copy. Requires userDataDir. (Playwright strips Chromium's --profile-directory, so copying is the only way to select a named profile.)

Schema Changelog

Changes observed during successful MCP inspections.

  1. Addedv0.9.1

TDQS

A4.9/5.0
Behavior5/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries the full disclosure burden and delivers thoroughly: headless Chromium with no display needed, prerequisites (Playwright install + CLIPY_API_KEY 'ingest' scope), refusal of userDataDir while live Chrome holds it locked, safe profile-copy semantics, storageState identity limitations (IndexedDB, service workers, cross-origin auth), and the warning that Clipy never focuses or foregrounds a window. This is exemplary behavioral coverage for an unannotated tool.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is long (~400 words), but every sentence carries real weight for a 13-parameter tool with no annotations; the core purpose and usage trigger are front-loaded. Minor redundancy — the profile-copying safety guarantee and 'never focuses' warning recur across the description and schema — keeps it from a 5, though no sentence is filler.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a 13-param mutation-capable tool with no annotations and no output schema, the description is remarkably complete: purpose, usage context, prerequisites, CLI-only exclusions, auth/identity limitations, edge cases (live Chrome lock, cross-origin auth gaps), and the downstream tool sequence. The only thing unstated is the exact return-value shape, which the opening sentence partially covers and which is reasonably delegated given no output schema.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters5/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Despite 100% schema coverage (baseline 3), the description adds substantial meaning beyond the schema: inter-parameter interplay (width/height ignored when viewports is set; storageState mutually exclusive with userDataDir), the semantic role of type (so the summary reads correctly), that notes BECOME the transcript for silent headless captures, and the deep subtleties of profileDirectory (copying vs. deviating from live profile). All 13 parameters get behavioral context the schema alone cannot convey.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The first sentence states a specific verb ('Record a web app HEADLESSLY'), resource (web app), and concrete output ('share link + agent-context URL'), distinguishing it sharply from siblings like start_recording (local/desktop capture). It also names what is NOT available (real Mac screen via ScreenCaptureKit, cookie/localStorage quick injection), so an agent can tell this headless variant apart without opening any schema.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines5/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

Gives an explicit trigger condition ('Use this to capture the outcome of work you just did — e.g. after building a feature') and explicit exclusions ('Recording the REAL Mac screen ... is CLI-only ... not available via MCP'), plus a follow-up sequence ('call wait_for_artifacts then get_agent_context'). Little is left to inference about when to deploy or avoid this tool.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.