webmcp-gen
browserbase/skills
Créer, compiler et valider des scripts d'initialisation WebMCP spécifiques à un site à partir d'une URL cible et des fonctionnalités souhaitées de l'outil.
...Développer toutWebMCP Gen
Créez des outils WebMCP spécifiques à un site web en rédigeant un manifeste, en le compilant en un script d'initialisation, puis en vérifiant que Chrome enregistre et lance ces outils.
Cette compétence n'appelle pas d'agent imbriqué. Il vous appartient d'explorer la page, de rédiger le fichier manifest.json et de procéder à des itérations en fonction du résultat de la validation.
Vérification de la configuration
Depuis le répertoire de la compétence, installez les dépendances si elles ne le sont pas déjà :
cd skills/webmcp-gen
pnpm install
Cela installe le paquet Stagehand épinglé ainsi que la chaîne d’outils TypeScript (tsx,
typescript, @types/node) utilisée pour exécuter le fichier stagehand-example.ts généré.
Workflow
- Choisissez un slug d’artefact comportant exactement une barre oblique :
/
Exemple :
example.com/page-context
- Générer le squelette de l'artefact :
node scripts/scaffold.mjs example.com/page-context --url https://example.com
- Explorer la page cible à l'aide de la CLI
« browse» :
browse open https://example.com --local
browse snapshot
browse get title
browse get url
browse get text body
browse get html body
Privilégiez les commandes « browse snapshot », « page text » et l’inspection du DOM plutôt que les captures d’écran, sauf si la mise en page visuelle est importante. Utilisez la commande « browse stop » lorsque l’exploration est terminée.
Modifiez
les fichiers artifacts/. Le manifeste est la source de référence./ /manifest.json Compiler :
node scripts/compile.mjs artifacts/example.com/page-context
- Générez un exemple Stagehand exécutable (
stagehand-example.ts) et exécutez-le avectsx:
node scripts/generate-stagehand-example.mjs artifacts/example.com/page-context
npx tsx artifacts/example.com/page-context/stagehand-example.ts
- Valider :
node scripts/validate.mjs artifacts/example.com/page-context
- Si la validation échoue, examinez
les fichiers eval.jsoneteval-report.md, corrigezle fichier manifest.json, puis recompilez et validez à nouveau.
Contrat du manifeste
{
"domain": "example.com",
"task": "page-context",
"url": "https://example.com",
"generatedAt": "2026-06-04T00:00:00.000Z",
"tools": [
{
"name": "example_com_page_context",
"description": "Renvoie le contexte de la page.",
"inputSchema": {
"type": "object",
"properties": {},
"required": []
},
"implementation": {
"kind": "dom",
"source": "return { success: true, title: document.title, url: location.href };"
},
"fixtureInput": {}
}
]
}
Règles de rédaction
implementation.sourceest inséré à l’intérieur deasync (input) => { ... }; écrivez des instructions JavaScript, et non une fonction wrapper complète.- Renvoyez un objet sérialisable au format JSON.
- Le code WebMCP s’exécute au sein de la page du navigateur. Utilisez les API natives du navigateur :
document,location,navigatoretfetchde même origine. - N’utilisez pas Playwright, Puppeteer, Stagehand, les aides XPath ou les commandes d’agent/navigateur à l’intérieur de `
implementation.source`. document.querySelectoretquerySelectorAllne doivent recevoir que des sélecteurs CSS valides pour le navigateur.- Pour rechercher du texte visible, utilisez
Array.from(document.querySelectorAll(...)).find((el) => (el.textContent || "").includes("...")). - N'incluez pas de clés API, de jetons « bearer », de cookies, de secrets localStorage ni d'identifiants utilisateur.
- N’utilisez pas
evalninew Function. - Évitez les actions destructrices, sauf si l’utilisateur les a explicitement demandées.
- Concevez des implémentations défensives : vérifiez s’il manque des éléments et renvoyez des réponses structurées
de type { success: false, error: "..." }. - Les scripts d'initialisation générés n'enregistrent les outils WebMCP que dans le cadre supérieur.
Structure de sortie
artifacts///
manifest.json
webmcp.init.js
stagehand-example.ts
eval.json
eval-report.md
Pour transformer cet exemple en projet autonome, créez une application Stagehand à l’aide de
npx create-browser-app et placez-y le fichier webmcp.init.js généré (chargez-le
avec page.addInitScript({ path: "webmcp.init.js" })).
---
name: webmcp-gen
description: Create, compile, and validate site-specific WebMCP init scripts from a target URL and desired tool capability.
license: MIT
---
# WebMCP Gen
Author website-specific WebMCP tools by writing a manifest, compiling it to an init script, and validating that Chrome registers and invokes the tools.
This skill does not call a nested agent. You are responsible for exploring the page, writing `manifest.json`, and iterating based on validation output.
## Setup check
From the skill directory, install dependencies if they are not already installed:
```bash
cd skills/webmcp-gen
pnpm install
```
This installs the pinned Stagehand package plus the TypeScript toolchain (`tsx`,
`typescript`, `@types/node`) used to run the generated `stagehand-example.ts`.
## Workflow
1. Pick an artifact slug with exactly one slash:
```text
<domain>/<task>
```
Example:
```text
example.com/page-context
```
2. Scaffold the artifact:
```bash
node scripts/scaffold.mjs example.com/page-context --url https://example.com
```
3. Explore the target page with the `browse` CLI:
```bash
browse open https://example.com --local
browse snapshot
browse get title
browse get url
browse get text body
browse get html body
```
Prefer `browse snapshot`, page text, and DOM inspection over screenshots unless visual layout matters. Use `browse stop` when exploration is complete.
4. Edit `artifacts/<domain>/<task>/manifest.json`. The manifest is the source of truth.
5. Compile:
```bash
node scripts/compile.mjs artifacts/example.com/page-context
```
6. Generate a runnable Stagehand example (`stagehand-example.ts`) and run it with `tsx`:
```bash
node scripts/generate-stagehand-example.mjs artifacts/example.com/page-context
npx tsx artifacts/example.com/page-context/stagehand-example.ts
```
7. Validate:
```bash
node scripts/validate.mjs artifacts/example.com/page-context
```
8. If validation fails, inspect `eval.json` and `eval-report.md`, patch `manifest.json`, then compile and validate again.
## Manifest contract
```json
{
"domain": "example.com",
"task": "page-context",
"url": "https://example.com",
"generatedAt": "2026-06-04T00:00:00.000Z",
"tools": [
{
"name": "example_com_page_context",
"description": "Returns page context.",
"inputSchema": {
"type": "object",
"properties": {},
"required": []
},
"implementation": {
"kind": "dom",
"source": "return { success: true, title: document.title, url: location.href };"
},
"fixtureInput": {}
}
]
}
```
## Authoring rules
- `implementation.source` is inserted inside `async (input) => { ... }`; write JavaScript statements, not a full function wrapper.
- Return a JSON-serializable object.
- WebMCP code runs inside the browser page. Use browser-native APIs: `document`, `location`, `navigator`, and same-origin `fetch`.
- Do not use Playwright, Puppeteer, Stagehand, XPath helpers, or agent/browser commands inside `implementation.source`.
- `document.querySelector` and `querySelectorAll` must receive valid browser CSS selectors only.
- To find visible text, use `Array.from(document.querySelectorAll(...)).find((el) => (el.textContent || "").includes("..."))`.
- Do not include API keys, bearer tokens, cookies, localStorage secrets, or user credentials.
- Do not use `eval` or `new Function`.
- Avoid destructive actions unless the user explicitly asked for them.
- Make implementations defensive: check for missing elements and return structured `{ success: false, error: "..." }` responses.
- Generated init scripts register WebMCP tools only in the top frame.
## Output layout
```text
artifacts/<domain>/<task>/
manifest.json
webmcp.init.js
stagehand-example.ts
eval.json
eval-report.md
```
To turn the example into a standalone project, scaffold a Stagehand app with
`npx create-browser-app` and drop the generated `webmcp.init.js` into it (load it
with `page.addInitScript({ path: "webmcp.init.js" })`).
Tous les fichiers
8 fichiersInstaller webmcp-gen
Téléchargez et décompressez les fichiers de compétences dans votre répertoire .claude/skills/.
Télécharger le ZIPClonez le dépôt et copiez les fichiers de compétence dans votre projet.
git clone https://github.com/browserbase/skills/tree/main/skills/webmcp-gen # Copy SKILL.md to your .claude/skills/ directory
Copier





Maison
