Home

Dugo is your modern WordPress foundation built for teams that care about security, speed, and predictable content operations. It combines battle-tested WordPress Multisite with OpenResty front-end performance and a local Rust-based automation layer that lets you safely read and (dry-run) write content using tools—not ad-hoc scripts.

Whether you publish daily or ship updates hourly, Dugo turns WordPress into a reliable content platform with guardrails, observability, and zero drama.

Why teams choose Dugo

• Security with guardrails: Site-scoped JWT tokens, local Unix-socket automation (no open ports), and hardened units by default.
• Faster workflows: Self-service tools for content teams and developers—list posts, set a static homepage, draft a landing page—without clicking through screens.
• Safe by design: Dry-run write operations show exactly what would change before anything is applied. No surprises.
• Operations you can trust: Systemd-managed services, sensible logging (JSON, structured), and docs/runbooks that keep incidents short and weekends free.
• Future-ready: Rust-based MCP server with LSP-style framing ensures low-latency local automation that scales with your ambitions.

What Dugo is (and how it’s different)

Dugo is a WordPress Multisite (subdomain mode) for dugo.com, fronted by OpenResty, and secured end-to-end so your automation doesn’t become a liability. Under the hood:

• OpenResty terminates TLS and forwards Authorization to PHP-FPM for REST flows.
• A MU plugin issues site-scoped JWT tokens; each site’s token lives under /var/www/.ssh/dugo/<site>.jwt with strict permissions.
• A local Rust MCP server (Unix domain socket) exposes a clean tool surface you can call from CI, CLI, or assistants:
• Reads: health, users.me, sites.info, settings.get, posts/pages/media list/get
• Writes (safe): posts/pages update/delete (with dry_run) and settings.update
• Everything runs locally over UDS with Content-Length framed JSON-RPC (LSP-style) for reliability and speed.

The result: a fast, secure, automation-friendly WordPress that’s delightful for both editors and engineers.

What you can do today (examples)

• Audit content:
• List latest posts: posts.list (per_page=2)
• Get media details: media.get (id=…)
• Shape the site:
• Fetch settings: settings.get
• Set a static front page (dry-run preview first), then apply with settings.update
• Move confidently:
• Update a post title with posts.update (dry_run=true) to see the exact request before it’s applied.
• Plan a content cleanup using pages.delete (dry_run=true)—no accidental removals.

Prefer clicks? Keep using wp-admin. Need speed and safety? Use the tools. You can mix both without stepping on each other.

Benefits for content teams

• Draft faster with templated sections and repeatable steps.
• Reduce back-and-forth with developers—common changes are one command away.
• Lower risk: “preview then apply” workflows mean no more midnight rollbacks.

Benefits for developers and DevOps

• Local-only automation via a Unix socket—no exposing admin APIs to the internet.
• First-class observability: structured logs around each call (tool, method, HTTP status, duration), with tokens never logged.
• Ansible-backed OpenResty role and documented runbooks that keep infra tidy.

How Dugo works (at a glance)

1) Request comes in (tool call) → MCP server receives framed JSON-RPC over UDS. 2) The server validates input, attaches the site’s JWT, and calls the WordPress REST API. 3) For list endpoints, pagination headers are captured and returned as { data, meta } so clients can paginate precisely. 4) For write operations, dry_run=true returns a safe preview ({ method, path, query/body })—no change unless you opt-in.

All of this happens locally with minimal latency and zero public exposure.

Security posture that scales

• Site-scoped JWTs in locked-down paths (mode 600) owned by the service user.
• UDS permissions set to 0660 with a dedicated group (e.g., devopsx)—easy to grant, easy to audit.
• Systemd hardening out of the box (and mindful exceptions only where needed).

Built for real publishing, not demos

• Multisite (subdomain) structure for future growth.
• OpenResty for consistent TLS and header handling.
• WordPress core features—blocks, menus, themes—still first-class.
• Optional chat widget MU plugin for site engagement.
• REST introspection + OpenAPI spec in docs to keep clients honest and up-to-date.

Who Dugo is for

• Content teams that want to move faster—without cutting corners.
• Product and growth teams that need reliable landing pages and experiments.
• Ops and platform teams who value least-privilege automation and observability.

Get started in minutes

• Browse tools (local): tools/list
• Verify auth: users.me
• Review settings: settings.get
• Try a safe write: posts.update { id, post, dry_run:true }

Want us to wire this into your workflow? We’ll set up a short, focused demo tailored to your use cases.

FAQs

Is this still WordPress? 100%. We add the missing guardrails, automation, and operational polish.

Can we publish from the command line? Yes—with approvals. Dugo defaults to dry_run previews on write flows so you can build “preview → approve → apply” pipelines.

How does auth work? Each site has a site-scoped JWT issued by a MU plugin, stored locally with strict file permissions. The automation layer reads from file first (no env token drift).

Can we keep using wp-admin? Absolutely. Dugo complements wp-admin; it doesn’t replace it. Editors keep their flows; teams gain safe automation.

What about hosting? Dugo runs on Debian with OpenResty + OpenResty + MariaDB. We provide Ansible role(s) and runbooks; bring your cloud.

The bottom line

Dugo modernizes WordPress for teams who need to move fast—and prove it’s safe. You get the publishing muscle you already know, plus the automation, guardrails, and observability you’ve always wanted.

Ready to see Dugo on your content? Book a 25-minute walkthrough and we’ll show your team how to publish faster—with fewer incidents and more confidence.