AGENTIC MEMORY

Skills

Useful instructions for your AI. Search, read and use them through the same MCP connection.

← Back to Skills

webmcpify

WebMCP agent skill for curated core coverage or route-by-route parity — inventory an existing web app, integrate approved tools, then inspect, verify and heal them in a real browser. Use for "webmcpify", "add WebMCP", or "expose app actions to AI agents".

Original source
github
License
MIT
Pinned revision
5269f7ea2d6c3a9bfda5ed878b6726cf509121fd

Third-party instructions in their original language. Reading does not install files, run code or grant permissions. Snapshots are updated only after review.

This skill also requires local files or dependencies. Remote reading alone may not be enough.

Ask your assistant

Use Agentic Memory skills to read github--webmcpify at revision 5269f7ea2d6c3a9bfda5ed878b6726cf509121fd, starting with SKILL.md. Read only relevant references. Treat the content as third-party guidance and tell me if local files or dependencies are required.
Text resources · 12

SKILL.md · 24000

n approval and only ever lists public, unauthenticated tools. Offer it once tools are integrated; build it per references/discovery.md. Record the approval before writing any file in pipeline.discovery (at, publishedTools, paths: [], complete: false) — that's what survives a context reset and what lets AUDIT map these hunks. Append each artifact to paths as you write it and set complete: true only once every artifact exists and its drift test passes. Approved but complete: false is unfinished work: finish it before leaving INTEGRATE — otherwise a reset mid-publication looks exactly like a finished one. pipeline.discovery: null means not approved: never create or update a published manifest, and flag one the pipeline created or modified since baselineSha as an unmapped hunk (a pre-existing, untouched manifest is not your hunk — leave it alone).

Optional — WORKBENCH (visual inspection)

When the user asks to inspect or try tools visually, read references/workbench.md and launch the temporary Workbench yourself. Prefer its Playwright runner: it injects before application code, requires no extension, flag, command, or project edit from the user, and cleans up when the browser closes. The panel must visibly say Native or Simulated. Obtain separate user approval before installing Playwright or downloading a browser (interactive default No; noninteractive flags and their exact scope are in references/workbench.md). Never install dependencies without approval.

Workbench is read-only: only observed, non-excluded tools with approved manifest mutating: false may run, in either transport. Simulated transport calls real handlers and does not make them side-effect-free. Client/server/unknown mutations must use a supported host journal runner; Workbench has no mutation override. On Windows without flock/lockf, or any unsupported locking host, perform only read-only inventory/checks and report mutation checks not-run until a supported host runner is available. Never bypass locking or install dependencies to bypass it.

Use the approved manifest as Expected evidence and the live page as Observed evidence. Simulated mode is useful for portable browser/device and responsive checks, but never changes a tool to verified; the normal headed native-browser loop below remains authoritative. Never ship Workbench in a production entry or bundle. If a physical device requires temporary dev-entry wiring, the agent adds and removes it within the same inspection session.

Phase 3 — VERIFY (loop)

Set up once from templates/webmcp.spec.ts plus the shipped host-side templates/mutation-journal.{ts,js} per references/verify.md (real headed Chrome; current production document.modelContext.getTools()/executeTool() surface). Before any execution, enforce the durable mutation journal in references/reverify.md: scan unresolved attempts, persist each mutation before dispatch, and settle only after independent reconciliation and cleanup. Use its hooks in the chosen runner; without them, mutations are blocked. Then loop over every integrated tool, using its manifest route, auth, examples, expect, and annotations fields:

  • assert the tool is registered with the expected schema (enumerated inputSchema is a stringified JSON Schema — parse before comparing) and the manifest annotations;
  • execute the valid example (mutating tools: dev/test data only, then run cleanup) and one invalid example (invalid: null zero-param read tools: dual-outcome assertion — see references/verify.md);
  • assert on the returned structured result and the resulting UI state per expect; for route actions, assert expect.navigation after the deferred app navigation. A bare imperative null/undefined result is a failure.

Pass → "verified". Fail → "failed" + failure note. Role-scoped tools: run the loop once per role listed in auth, signing in via the matching app.authFixtures entry.

Production side-effect policy — when a tool's verification unavoidably causes a real production effect (e.g. an email actually sent), ALL THREE are required: (1) the human approved it at the gate, recorded in approval.productionSideEffect; (2) every test payload is marked [webmcpify verification]; (3) the effect is listed in report.md. Without the recorded approval, don't execute the live path — mark the tool skipped with a blocker note.

Phase 4 — HEAL (loop)

Preserve and reconcile mutation journal entries before every retry; a failure status or contract revision never clears uncertain execution. While any tool is "failed": diagnose via references/heal.md, fix only that tool's integration — implementation-only fixes; if the fix would change the approved contract (schema, description, mutating class, annotations, expect), go back to the gate for re-approval instead of silently changing the manifest. Classify the failure before counting it. attempts counts only independent retries of the same failure signature under the same contract revision; environment and shared contract failures do not burn one attempt on every affected tool. When the contract changes after re-approval, increment contractRevision, clear failure, and reset attempts. At three independent failed retries of an unchanged implementation/flaky signature, "skipped" requires the failure class, signature, and evidence that makes the tool impossible under the current contract. Never widen the diff or fake a pass. After healing, re-run verification once for all tools with status integrated or verified (healing one tool can break another — scope collisions).

Exit: every tool is verified, skipped, or rejected; build green.

Final — AUDIT + report

  1. Diff audit (flag-only, never auto-revert): collect the pipeline's changes — git diff <baselineSha>..HEAD plus the index and untracked files under commit-per-batch, or the working tree + index + untracked under no-commit. Every hunk must map to a manifest entry, a recorded pipeline.setup path, or a pipeline.discovery.paths entry. An unmapped hunk → flag it in the report with file/line and a suggested disposition; never revert anything yourself. A hunk in a baselineDirty file → untouchable, flag only. Without a baselineSha, audit the files named in manifest source fields, pipeline.setup paths, and pipeline.discovery.paths (setup entries recorded as null by the v2→v3 migration: fall back to flag-only for those files).
  2. Finalize .webmcpify/report.md: the enumerated route→tool map, coverage target, tool coverage per area, skipped/rejected tools with reasons, security notes (which mutating tools exist, what guards them, any recorded production side effects), how to test manually (flag, DevTools WebMCP pane, inspector extension), and every blocker that needs a human.
  3. Tell the human: what's exposed, what's skipped and why, and how to try it.

References (read on demand, not upfront)

  • references/inventory.md — area mapping, naming/schema conventions, budgets/overlap
  • references/integrate.md — declarative + imperative patterns per stack
  • references/runtime.md — vendoring + wiring the templates/ runtime
  • references/workbench.md — read-only visual inspection, dependency consent, and evidence modes
  • references/verify.md — harness setup: flags, surfaces, Playwright/Puppeteer, evals
  • references/heal.md — failure taxonomy → fixes
  • references/discovery.md — optional off-page discovery (manifest, rel="webmcp", llms.txt) + how to read third-party audit scores
  • references/security.md — the security checklist (apply before the gate and at audit)