# domani **Category:** 💬 Communication **Repository:** https://github.com/gwendall/domani **Views:** 0 **Installs:** 0 **Upvotes:** 0 **Directory Page:** https://allmcps.com/mcp/domani ## Description Domains + send/receive email + inbound webhooks + DNS for AI agents. One API, MCP, CLI. ## Claude Desktop Quick Installation Heuristic fallback — verify the package name and runner against the repository README before running it. Uses `npx` (confidence: low): ```json "mcpServers": { "domani": { "command": "npx", "args": ["-y","domani"] } } ``` ## Documentation & README # domani Domains and email - for humans and AI agents. Register domains, manage DNS, create mailboxes, send and receive email. From your terminal, your agent, or the web. [![npm version](https://img.shields.io/npm/v/domani-cli.svg)](https://www.npmjs.com/package/domani-cli) [![license](https://img.shields.io/npm/l/domani-cli.svg)](https://github.com/gwendall/domani/blob/main/LICENSE) ## How it works domani gives you one account and multiple ways in: - **[Web](https://domani.run)** - Dashboard with a full inbox (compose, reply, threads), DNS editor, domain management - **CLI** - This package. Everything the web app does, from your terminal - **[MCP Server](https://domani.run/mcp)** - typed tools for Claude Code, Cursor, Codex, and any MCP-compatible agent - **[OpenClaw](https://openclaw.com)** - `openclaw skills install @gwendall/domani` - **[Agent Skill](https://domani.run/skill.md)** - Step-by-step guide your agent can follow. Install with `npx skills add domani.run` - **[REST API](https://domani.run/docs)** - Direct HTTP access to everything All interfaces share the same API key and the same data. ## Install ```bash npm install -g domani-cli ``` ## Secure MCP bridge Agent plugins can use Domani without placing an API key in a prompt, shell history, or editor configuration: ```bash domani login --surface mcp domani mcp serve ``` `domani login` stores the credential in the operating-system keychain when one is available. The stdio bridge resolves it locally and forwards MCP requests to `https://domani.run/mcp`; stdout remains reserved for JSON-RPC messages. For an agent acting on someone else's behalf, request a scoped, expiring credential instead of their account key: ```bash domani login --scopes domains:read,search --label "Project agent" --expires-in 86400 ``` The approval screen shows the requested access and the resulting credential is stored in the keychain without being printed. After login, prove one complete inbound loop before browsing other tools or buying a domain: ```bash domani email create myagent@domani.run domani email webhook myagent@domani.run --url https://my-agent.example/webhook domani email webhook-test myagent@domani.run ``` Use `--surface plugin`, `--surface skill`, or `--surface api` when that is the entry point. This keeps activation attribution consistent without exposing a credential. This installs the `domani` command. Or run directly with `npx`: ```bash npx domani-cli search myapp .com .dev .ai ``` ## Quick start ```bash # Domain domani search myapp .com .io .dev # Check availability domani buy myapp.dev # Purchase a domain domani connect myapp.dev vercel # Auto-configure DNS for Vercel # Email domani email create hello@myapp.dev # Create hello@myapp.dev domani email send hello@myapp.dev \ --to hi@friend.com --subject "Hello" --body "Sent from my terminal" domani email forward hello@myapp.dev \ --forward-to me@gmail.com # Forward inbound to personal email # Health domani status myapp.dev # DNS, SSL, email, expiry check ``` ## Examples ```bash # Find available domains with a budget domani search startup --expand --max-price 20 # AI-powered name suggestions domani suggest "minimalist productivity app" --style brandable --tlds com,dev,ai # Buy multiple domains at once domani buy startup.dev startup.ai --yes # Set up Vercel + Google Workspace in two commands domani connect startup.dev vercel domani connect startup.dev google-workspace # Full email workflow: create, send, check inbox, forward domani email create hello@startup.dev domani email send hello@startup.dev \ --to investor@vc.com --subject "Deck" --body "Here's our deck." domani email inbox hello@startup.dev --direction in domani email forward hello@startup.dev --forward-to me@gmail.com # Webhook for inbound emails (for bots, support systems, etc.) # CURSOR_AUTH contains the complete value, e.g. "Bearer sender-key" domani email webhook hello@startup.dev --url https://myapp.dev/hooks/email \ --authorization-env CURSOR_AUTH domani email webhook-test hello@startup.dev # Provision domain + mailbox + authenticated event webhook in one call. # The secret stays in the environment; only its variable name is in argv. AGENT_AUTH="Bearer sender-key" domani provision agent.dev \ --webhook https://agent.example/inbox --authorization-env AGENT_AUTH # Export DNS records before making changes domani dns startup.dev snapshot domani dns startup.dev set TXT @ "v=spf1 include:_spf.google.com ~all" # Pipe to jq (auto-JSON when piped, no --json needed) domani list | jq '.domains[] | {domain, expires_at}' # Introspect command schemas for agent integration domani schema buy --json ``` ## Commands ### Domains ``` domani search [tlds...] Check availability across TLDs (--expand for 30+) domani suggest AI-powered domain suggestions (--style, --lang, --tlds) domani buy Purchase one or more domains domani adopt Inspect and plan a safe connection or transfer domani transfer Transfer registration, preserving current nameservers domani renew Renew a domain (--years 1-10) domani import Import a domain you own elsewhere (DNS monitoring only) domani list List your domains domani status Health check (DNS, SSL, email, expiry) domani tlds List all TLDs with pricing (--sort, --max-price) domani whois WHOIS/RDAP lookup ``` ### Email ``` domani email list List all mailboxes domani email create user@domain Create a mailbox domani email delete user@domain Delete a mailbox domani email inbox user@domain List messages (--folder, --view, --direction) domani email folders user@domain List folder and view counts domani email archive user@domain --message-ids m1,m2 domani email trash user@domain --message-ids m1 domani email restore user@domain --message-ids m1 domani email read|unread|star|unstar user@domain --message-ids m1,m2 domani email send user@domain Send an email (--to, --subject, --body, --cc, --bcc) domani email forward user@domain Forward inbound to a personal address (--forward-to) domani email webhook user@domain Forward inbound as JSON (--url, --authorization-env, --api-key-env, --clear-headers) domani email webhook-test user@domain Deliver one signed test event to the configured webhook domani email setup --domain Auto-configure MX, SPF, DKIM, DMARC domani email status --domain Check email DNS health domani email connect --domain Connect external provider (Gmail, Fastmail, Proton) ``` ### Mailzero assistant (private preview) ``` domani assistant today Now, Needs you, Waiting, Upcoming, Handled domani assistant settings Opt-in state, consent, and mailbox scope domani assistant set Change settings (--enable, --shadow, --pause, --mailboxes, --none, --days) domani assistant preview Record consent and start a background history import (--mailboxes, --consent) domani assistant backfill|retry Follow the import or requeue its terminal failures domani assistant item One work item with its Decision and options domani assistant choose Record a decision (--item-version, --decision, --decision-version, --option) domani assistant instruct|snooze|ignore|take-over|correct domani assistant plan Exact preview of a prepared reply; nothing is sent by the CLI domani assistant activity Content-free interaction and receipt log domani assistant rules The standing delegations (match, assignee, level, grants) domani assistant approvals The plans waiting for you and the questions your agents asked domani assistant suggestions The rules the assistant proposes from what recurred domani assistant metrics The seven numbers per account and per rule (--days) domani assistant task The task envelope an assignee works from domani assistant lease|release|effects|escalate|report domani assistant export|delete Export or delete derived data (source mail is never touched) ``` Tokens need `assistant:read` for reads and `assistant:write` for changes. ### DNS ``` domani dns get List all DNS records domani dns set Add/update a record domani dns delete Remove a record domani dns snapshot Export DNS to file domani dns restore Restore DNS from snapshot domani nameservers Get or set nameservers (--reset for defaults) domani connect Auto-configure DNS for a provider ``` **Supported providers**: Vercel, Netlify, Cloudflare Pages, GitHub Pages, Fly.io, Railway, Render, Google Workspace, Fastmail, Proton Mail. ### Settings ``` domani settings View/update auto-renew, WHOIS privacy, security lock domani contact [view|set] Manage WHOIS contact info domani parking Manage parking page (enable/disable/price) domani analytics View parking analytics domani auth-code Get EPP auth code for outbound transfer domani transfer-away Check outbound transfer status ``` ### Account ``` domani login Log in to domani.run (opens browser) domani logout Clear saved credentials domani me Show account info domani billing Add or update payment method (opens browser) domani invoices List payment invoices domani token Print your API key domani tokens [list|create|revoke] Manage API tokens (scoped, expiring) domani webhooks [action] Manage webhook endpoints (auth headers via --authorization-env/--api-key-env) ``` ### Introspection ``` domani schema [command] Show command schemas for AI agent integration domani update Update to the latest version domani uninstall Remove domani CLI and config ``` ## Agent integration Built for AI agents and scripts, not just humans. **TTY auto-detect**: When stdout is not a terminal, the CLI automatically switches to JSON output and skips confirmation prompts. No `--json` flag needed. ```bash domani list | jq '.domains[].domain' ``` **Structured errors**: In JSON mode, errors include `code`, `hint`, and `fix_command` for auto-recovery: ```json { "error": "Not logged in", "code": "auth_required", "fix_command": "domani login" } ``` | Code | Fix | Description | |------|-----|-------------| | `auth_required` | `domani login` | Not logged in | | `payment_required` | `domani billing` | No payment method on file | | `contact_required` | `domani contact set` | WHOIS contact info missing | | `validation_error` | Read `hint` | Invalid input | | `not_found` | - | Domain doesn't exist or not owned | | `rate_limited` | Wait `Retry-After` | Too many requests | **Flags**: | Flag | Description | |------|-------------| | `--json` | Force JSON output | | `--fields ` | Filter JSON fields (comma-separated) | | `--dry-run` | Preview mutations without executing | | `--yes` | Skip confirmation prompts | **Input hardening**: All inputs are validated against path traversal, control characters, query strings, and double encoding - common agent hallucinations. **Schema introspection**: Run `domani schema --json` to get parameter types, constraints, and enums before constructing a command. ## Payments Domains are charged to your saved card. Add one at [domani.run/dashboard](https://domani.run/dashboard) or with `domani card add`. ```bash domani buy myapp.dev # Charged to saved card ``` ## Authentication | Method | Description | |--------|-------------| | `domani login` | Interactive login (opens browser) | | `$DOMANI_API_KEY` | API key as environment variable | | OS keychain | Credential saved by `domani login` when available | | `~/.domani/config.json` | Non-secret CLI settings, plus legacy fallback on systems without a keychain | The CLI checks `$DOMANI_API_KEY` first, then falls back to `~/.domani/config.json`. ```bash domani login # Interactive (opens browser) export DOMANI_API_KEY=domani_sk_... # Or set env var ``` Scoped API tokens can be created with `domani tokens create --scopes read,dns --expires-in 86400`. ## Environment variables | Variable | Description | |----------|-------------| | `DOMANI_API_KEY` | API key (takes precedence over saved config) | ## License [MIT](https://github.com/gwendall/domani/blob/HEAD/LICENSE)