Unofficial Windows WebView2 diagnostics and automation for Tauri 2.12 development builds.
This MCP server, io.github.Firzus/tauri-agent-kit, provides “Unofficial Windows WebView2 diagnostics and automation” tailored to Tauri 2.12 development builds. Its purpose is centered on Windows WebView2 behavior during Tauri development, supporting developers who need visibility into diagnostics and automation related to that component.
🛠️ Key Features
Unofficial Windows WebView2 diagnostics
Windows WebView2 automation
Targeted for Tauri 2.12 development builds
🚀 Use Cases
Troubleshooting WebView2-related issues during Tauri 2.12 development
Automating WebView2 diagnostics/workflows on Windows
⚡ Developer Benefits
Focused tooling for Windows WebView2 in Tauri 2.12 builds
⚠️ Limitations
Unofficial scope
Limited to Windows WebView2 diagnostics and automation for Tauri 2.12 development builds
An opinionated development stack for coding agents: you describe what you want,
the agent asks only the decisions that are yours, builds it test-first, has it
reviewed independently, shows it working, and ships only when you say so.
The stack is a set of skills that call each other, kept in
skills/stack/. Next to it, the collection offers standalone
skills for engineering, web, and game work that you can install one at a time.
These are independent, community-maintained skills, not official vendor products.
Agents fail in predictable ways: they build before understanding the request, ask
you what the repository already says, grade their own work, bury you in jargon or
in ceremony, and publish without asking. The stack answers each failure with an
opinion.
Understand before building. The agent restates the outcome and how you will
both know it works before it changes any code.
Facts are looked up; only your decisions are asked. The agent reads the code,
history, and documentation first. It asks only about choices you own (behavior,
scope, cost, a step that is hard to undo) before the build starts, and takes
every other choice itself, telling you which it took and why.
Ceremony matches the work. The agent sizes each request as Direct, Issue, or
Project, after what it needs in Linear, and tells you why. A typo needs no issue; a feature gets one; a large
effort gets a project.
No agreement, no code. Beyond a Direct fix or a Linear issue that is
ready to start, the agent builds only what you agreed to.
Linear holds the work. Each feature or fix is a Linear issue and each large
effort a Linear project, written so that any later session continues from it.
One unit per session. Large work advances in units that one session can
finish, check, and hand over as a change you can review in one sitting. Each
conversation does one thing (a task, a fix, an investigation, an experiment,
an interview, or a take-stock), then stops; the next starts from Linear. The
agent plans only as far as what is known, and takes stock with you whenever a
result changes the way ahead.
Tests first. Each behavior starts with a failing test wherever a test
boundary exists.
Evidence over claims. Independent read-only reviewers check requirements,
standards, and correctness, and the agent shows you the result running.
Explained, not simplified. The agent keeps the real technical terms, defines
each one the first time it appears, and presents every decision with its costs,
whether it can be undone, and a recommendation.
You hold the keys. Shipping (push and pull request), merging, and deploying
each wait for your explicit yes.
General rules (communication, authorization, delegation, verification, Git) live
once in a shared operating policy;
each skill holds only what is specific to its task.
How it works
flowchart LR
request([Your request]) --> work
work -.->|bug, research, experiment| specialist{{"debug · research · prototype"}}
specialist -.-> work
work --> size{{Direct · Issue · Project}}
size -->|Direct| build[Build test-first]
size -->|Issue or Project| interview[interview, when decisions are open]
interview --> agree([You agree])
agree -->|new conversation after an interview| build
build --> review[code-review]
review --> show([Result shown working])
show --> ship([Ship when you say yes])
You start everything with /work and your request, in your own words. The agent
first finds the cause of a bug or gathers the evidence a decision needs, then sizes
the work:
Size
When
What you do
Direct
The request says everything that matters and is easy to undo
Check the result, then say whether to ship
Issue
One unit: fits one session and one reviewable change
Agree on the Linear issue (when decisions are open, you answer them in a first conversation that ends there), check the result, say whether to ship
Project
Several units, or questions that need research, an experiment, or a later decision first
Agree on a Linear project and its first issues; then start a new conversation for each unit with /work on the project or one of its issues: the agent runs that unit, asks for your decisions in Interview units and for your review, names the next one, and takes stock with you when results change the plan
Issue-size and Project-size work need Linear: when the agent cannot reach it, it stops and
tells you how to reconnect. Direct work does not use Linear.
Get started
You need a coding agent that supports skills and subagents, and Node.js and npm
for the installer.
Open a terminal in your project and install the stack:
bash
npx skills add Firzus/agent-skills --skill setup-harness work interview debug prototype research code-review
The installer asks for your agent and destination. It installs in the project
by default; add -g to install globally.
Run setup-harness once. It installs the shared operating policy in your
personal instructions, after showing you the complete change. The stack
relies on it.
Run /work with a small request, for example /work fix the typo in the confirmation email. Check the result it shows you, then tell it whether to ship.
If an invoked skill is not found, check the installation location and restart the
session.
Browse, update, or remove installed skills
bash
# Browse the collection without installing it
npx skills add Firzus/agent-skills --list
# Choose skills interactively
npx skills add Firzus/agent-skills
# Manage installed skills
npx skills list
npx skills update work
npx skills remove work
Stack and engineering skills assume the shared operating policy, even when used alone.
Requirements
Installing instructions does not install every tool they describe or authorize
every action they can perform. Check the selected skill's prerequisites first.
Workflow
Additional requirements
Stack and engineering skills
The shared operating policy installed by setup-harness; these skills rely on it and repeat only its safety boundaries
The stack
Git in the project; a Linear workspace the agent can read and write (for example through the Linear MCP server) for Issue-size and Project-size work; GitHub CLI or another way to open pull requests to ship
Independent reviews and delegated research
An agent with subagent support
Figma workflows
The Figma integration, account access, and approval for external writes
Cloudflare operations
The cf CLI from the npm package cf (open beta) and a Cloudflare account; the skill proposes the global install and waits for approval
Video reports
FFmpeg and access to the application being recorded
Agent play in Unity
The Unity CLI with com.unity.pipeline in the project, the Input System active, Python 3, and a host that can run the skill's play model as a subagent; FFmpeg to film a session
Unity performance review
Python 3.11 or later and Git; the Unity CLI with com.unity.pipeline in the project to audit import and project settings
Runbooks
Bash to run them (Git Bash on Windows); an authenticated GitHub CLI to set secrets and variables, otherwise the runbook lists them to set by hand
YouTube transcription
Available captions, or the audio/transcription tools required by the selected route
Image generation
An authenticated Codex CLI setup with the image-generation capability described by the skill
Wordmark lettering
The image-generation setup above, and the potrace npm package as a project dev dependency, added after approval
Reverse engineering
The reverse-engineer MCP server for the fast route (Node.js 24.11+); the skill installs Ghidra, jadx or ilspycmd per user when a task needs them
Host support for installing skills does not guarantee identical behavior or tool
availability. Explicit-invocation workflows such as work, improve-codebase, and
setup-harness run only when you select them.
Personal harness instructions
setup-harness asks which harnesses
and languages to configure, previews the complete changes, and waits for approval.
It adds personal instructions without replacing the built-in system prompt and
creates no backups. Existing unrelated instructions are preserved.
Harness
Personal instruction destination
Codex (app and CLI)
One shared AGENTS.md per CODEX_HOME (default ~/.codex)
Cursor
User Rules in Customize > Rules; manual handoff if UI editing is unavailable
Claude Code
~/.claude/CLAUDE.md
Cursor's project AGENTS.md is not a global substitute. See the
native destinations
for loading limits, and review the
shared operating policy
before running this skill.
Tauri companion tooling
The tauri skill remains the agent-facing entry
point. Its optional Windows diagnostic application, tauri-agent-kit,
is maintained in this repository but is not an installable skill. Installing the
skill does not install the MCP server or Rust plugin: the skill proposes the
integration when a compatible project lacks it, and installs it only after
approval. Check the kit's compatibility and publication status before integrating
it into an application.
Reverse-engineer companion server
The reverse-engineer skill works
with shell commands alone, but it is faster and more economical with its read-only
MCP server, mcp/reverse-engineer. Installing
the skill does not install the server: register its npm package, reverse-engineer
(alpha), with your agent, as described in its README.
Explain shipped software (Electron apps, native binaries and Node addons, Go/Rust, .NET, APK) from its files, with cited evidence and an optional read-only MCP server.
Found a problem? Open an issue
with the skill name, agent and version, expected result, and actual result.
Remove secrets and private project data from examples.
For repository changes, read AGENTS.md for contribution boundaries
and validation. A skill lives at skills/<section>/<name>/SKILL.md, or one
level deeper for the Unity skills (skills/game/unity/<name>/); supporting
references and helpers stay in its folder. Keep the README catalog and
marketplace manifest aligned with skill folders.