Run a whole portfolio of websites from one window — and give an AI agent the same safe controls you have.

Running a website means living in a dozen browser tabs: GitHub for the code, Vercel for deploys, Cloudflare for DNS, Stripe for payments, Resend for email, Search Console for indexing. Multiply that by several sites and several accounts per provider, and most of the work becomes finding the right tab, logged into the right account.

WebOps Console is a local-first desktop app that collapses all of that into one window. Every site gets a strip of tabs holding its real provider dashboards, each signed in under whichever account that site uses. Alongside them sit local tabs the app renders itself: a dashboard of what the site is actually running, a design-token studio, and a DNS editor.

The second idea is the one that matters most: it is built so an AI agent can drive it safely. Every change to a provider is a two-step operation — an agent proposes a plan, and nothing happens until that plan is confirmed with a short-lived code. Secrets never leave your OS credential vault, and the API an agent talks to is bound to localhost behind a bearer token.

Nothing in this app phones home. There is no telemetry, no account, and no server. See Security — including how to have your own agent audit it independently.

Download the build for your OS from the latest release.

These builds are unsigned (code-signing certificates cost money and are tied to a legal identity). Your OS will warn you once. This is expected, and here is exactly what to click:

• Windows — SmartScreen says "Windows protected your PC" → More info → Run anyway.
• macOS — Gatekeeper says the app "cannot be opened" → right-click the app → Open → Open. If it still refuses: xattr -dr com.apple.quarantine "/Applications/WebOps Console.app".
• Linux — no signing prompt. The AppImage just needs the executable bit.

If you would rather not trust a prebuilt binary at all, build it from source — it takes two commands. That is the honest recommendation for anyone security-conscious.

The .deb declares them, but for the AppImage you need a WebKitGTK runtime and a secret service:

sudo apt install libwebkit2gtk-4.1-0 libgtk-3-0 gnome-keyring   # Debian/Ubuntu

The keyring (GNOME Keyring or KWallet) backs the credential vault and ships by default on most desktops.

Five ideas explain the whole app. The in-app ? icons repeat these where they are relevant.

1. Website — a record with a domain, repo, deploy/DNS providers, and services. Selecting one opens its tab strip.
2. Account — a saved login. Each account is an isolated browser session with its own cookie jar, so you can stay signed into two different Vercel accounts at once and point different sites at each. No more logging in and out.
3. Provider — an external service the console can open and operate. Tokens (only needed for agent-driven writes) live in your OS credential vault.
4. Plan → execute — every provider write is two steps. plan returns a description plus a short-lived confirmation code; execute requires that exact code. An agent can propose anything; nothing lands without confirmation.
5. Agent API — a localhost-only HTTP API plus a bundled MCP server exposing the same capabilities, behind a bearer token.

• Site intelligence. A native Rust crawler fingerprints each site's frameworks, third-party services, deploy/DNS/CDN providers, brand color, linked sites, and likely caveats, then writes a plain-English summary onto the dashboard.
• Auto-discovery when adding a site. Paste a URL, click Analyze, and the form fills in the name, providers, and detected stack.
• Design tokens. Pick a preset (including 21st.dev styles), tweak colors/fonts/radius, check WCAG contrast live, and export the theme as CSS variables, Tailwind v4 @theme, shadcn/ui tokens, or W3C DTCG JSON — the format your codebase actually consumes.
• DNS management. List live records and plan add/remove with a real editor: record types, TTL presets, the Cloudflare proxy toggle, comments, and pre-flight validation (CNAME-at-apex, missing MX/SRV priority, non-FQDN targets). Exports a portable BIND zone file.
• Per-site analytics tiles that light up as each provider account is connected.
• Windows Hello key vault (Windows only) — see Security.

The app runs a localhost-only API on http://127.0.0.1:4867, protected by a bearer token shown under Agent API. A bundled MCP server wraps it for any MCP-capable client.

{
  "mcpServers": {
    "webops-console": {
      "command": "node",
      "args": ["C:/path/to/WebOps Console/mcp/dist/index.js"],
      "env": {
        "WEBOPS_URL": "http://127.0.0.1:4867",
        "WEBOPS_TOKEN": "copy-from-the-Agent-API-screen"
      }
    }
  }
}

Read-only tools: check_console_health, list_websites, analyze_website, refresh_site_intel, get_deployment_map, list_style_presets, list_dns_records, list_vercel_env, get_console_openapi.

Write tools (always plan → execute): plan_website_action then execute_website_action, covering GitHub repos, Cloudflare/Vercel DNS, Vercel deploys/domains/env vars, Stripe webhooks, Render deploys, Neon branches, and Resend/Gmail sends.

Browser automation: open_page, open_backend, browser_click, browser_type, browser_snapshot, and friends drive the embedded tabs so an agent can operate a dashboard that has no API. Every action is written to an audit log readable via automation_log.

Full endpoint and action reference: docs/API.md.

Requires Node 20+ and the Rust toolchain for Tauri 2, plus your OS build prerequisites (Windows: C++ Build Tools · macOS: Xcode Command Line Tools · Linux: the WebKitGTK/GTK dev packages listed in docs/BUILD.md).

git clone https://github.com/BarnsL/webops-console.git
cd webops-console
npm install

npm run tauri dev      # run the desktop app with the live backend
npm run dev            # browser-only design preview (demo data, no native API, no secrets)
npm run build          # type-check, build the web layer, compile the MCP server
npm test               # frontend unit tests
npm run tauri build    # produce installers for your platform

src/                 React + TypeScript UI (App.tsx, api.ts, models.ts, styles.css)
src-tauri/src/       Rust backend, one module per concern
mcp/src/             Stdio MCP server that forwards to the localhost API
docs/                Architecture, build, API, operations, code map, getting started
.github/workflows/   CI (types, tests, fmt, clippy) and the cross-platform release build

New to the codebase? docs/GETTING_STARTED.md is a guided tour, and docs/CODE_MAP.md maps every module.

This app holds the keys to your infrastructure, so here is a straight account of how it is built, what it does not protect against, and how to verify all of it yourself.

Optional: paste a batch of API keys and encrypt them behind a Hello prompt.

• A TPM-backed Passport/Hello key pair signs a fixed challenge. That signature is SHA-256'd into a 32-byte key, which AES-256-GCM encrypts the blob (keys.enc).
• A fresh random 96-bit nonce is generated per encryption and stored as nonce ‖ ciphertext — no nonce reuse, and GCM gives authenticated encryption (tampering fails closed).
• Single-round SHA-256 is correct here because the input is a high-entropy RSA signature, not a password. It would be wrong for a passphrase, which would need Argon2/PBKDF2.
• The key is device- and user-bound and non-exportable: copying keys.enc to another machine is useless.

Read it yourself: src-tauri/src/hello.rs (~150 lines).

Being honest matters more than sounding secure:

• Malware running as your user. It could read the OS vault, trigger a Hello prompt, or read the API token, exactly as you can. This design defends against remote attackers, other users on the machine, and a stolen disk — not against code already running as you.
• Anyone at your unlocked machine. The embedded tabs are real logged-in sessions.
• The binaries are unsigned. A signed build proves origin; these don't. Build from source if that matters to you.
• /v1/health and /openapi.json are unauthenticated. They expose no data, but any local process can learn the app is running and see the API shape.
• Hello vault is Windows-only. On macOS/Linux keys rest in the OS keychain (encrypted at rest by the OS) without a separate biometric gate.
• Provider tokens are only as narrow as you make them. Scope them down; the app cannot.
• Third-party dashboards run real web content in embedded webviews, with the usual risks of browsing those sites.

At the time of writing, npm audit reports 5 advisories — all in the dev toolchain (vite / vitest / esbuild), none in shipped code:

npm audit --omit=dev   # -> found 0 vulnerabilities

Don't take any of the above on faith. Clone the repo and paste this to your own AI agent:

Audit this repository (a Tauri desktop app: Rust backend in src-tauri/src/, React frontend in src/). Verify or refute each claim below with file:line evidence, and tell me about anything I did not ask about:

1. Does the HTTP API bind only to loopback? Could any route be reached from another machine?
2. Is every mutating route behind authentication? Is the token compared in constant time?
3. Are provider tokens or the API token ever logged, serialized into a response, or written to workspace.json?
4. Review the AES-GCM usage in src-tauri/src/hello.rs: is a unique nonce used per encryption, is the key derivation appropriate for its input, and can ciphertext be tampered with undetected?
5. Can a provider write happen without a valid, unexpired plan and its confirmation code?
6. Does anything phone home? List every outbound network destination and what triggers it.
7. Does the frontend contain analytics, trackers, or third-party script loads?
8. Are there command-injection, path-traversal, or deserialization risks in the Rust code?

Useful commands to hand it:

# Every network call the backend can make, and every hard-coded destination
grep -rn "reqwest\|https://" src-tauri/src/

# Every log statement (check none of them print a secret)
grep -rn "println!\|eprintln!\|dbg!" src-tauri/src/

# Where the server binds, and the auth middleware
grep -rn "TcpListener::bind\|require_authorization\|constant_time_eq" src-tauri/src/api.rs

# Frontend network calls and any third-party origins
grep -rn "fetch(\|https://" src/

# Dependency advisories
npm audit --omit=dev
cargo install cargo-audit && cargo audit --file src-tauri/Cargo.lock

Reproduce the release yourself with npm run tauri build and compare against the published artifact. If you find something, please open an issue.

• Getting started — a guided tour for new developers.
• Architecture — trust boundaries, components, operation lifecycle.
• Build — per-OS prerequisites, packaging, signing, data locations.
• API reference — endpoints, MCP tools, provider actions.
• Operations — connecting providers and account sessions.
• Auto-update — the optional self-update mechanism (off by default).
• Code map — module-by-module orientation and the notation policy.
• Contributing — workflow and conventions.

See LICENSE. The optional webclaw sidecar is AGPL-3.0 and is not bundled — see src-tauri/binaries/README.md.

Built with Tauri, React, and Vite.