GoLive MCP sunucusu
Commit 31 Eki 2026Enables AI agents to deploy software by managing domains, DNS, email, cloud infrastructure, and security audits through a remote MCP server.
Ayrıca bilinen adı hapitech/golivemcp-docs
- Yıldızlar
- 0
- Araçlar
- —
- İndirmeler, 30 gün
- —
- En son sürüm
- —
- Son commit
- 31 Eki 2026
- Lisans
- MIT
GoLive MCP nedir?
Enables AI agents to deploy software by managing domains, DNS, email, cloud infrastructure, and security audits through a remote MCP server.
Özet, projenin README dosyasından oluşturuldu
GoLive MCP sunucusu hakkında
Developers and coding agents can use GoLive MCP to handle the final stages of software deployment, moving from code to a live production environment. This remote MCP server provides tools for managing the entire lifecycle of a web application, including domain registration, DNS configuration, email setup, and cloud infrastructure management. It allows agents to check domain availability, buy domains within a set budget, and manage Cloudflare zones without the user ever needing to handle raw registrar credentials.
To use the server, you can connect via Claude Code using the HTTP transport or add it as a custom connector in Claude Desktop and Claude.ai using an API key or OAuth 2.1. For clients that only support stdio, a bridge via npx mcp-remote is available. The platform prioritizes safety through a dry run mechanism for all changing tools, strict spending budgets that default to zero, and a security model where secrets are sent into the system but never read back to the agent. It also includes specialized tools for running security, privacy, and regulation audits before a launch.
Neler yapabilirsiniz
- 1Domain acquisition and planningAn agent can check if a specific domain is available and calculate the total cost of registration and renewal before making a purchase.
- 2Automated application deploymentA developer can instruct an AI to deploy a specific GitHub repository and monitor the process until the site is live.
- 3Environment variable and secret managementYou can task an agent with setting sensitive environment variables like Stripe keys and then triggering a redeployment.
- 4Pre-launch compliance and security checksBefore going live, an agent can perform comprehensive audits to ensure the software meets security and regulatory standards.
Projenin README dosyasından alınmıştır. Her kullanım durumu, oradaki bir alıntı ile kontrol edilir.
Otomatik kontroller
Çalıştırıldı 15 Kas 2026Tam rapor →Henüz doğrulanmadı. Bir sunucunun 80 puana, ciddi bir bulgu olmamasına ve kontrol edebilmemiz için yeterli veriye ihtiyacı vardır. Kontroller nasıl çalışır · Daha fazla puan için nelerin düzeltileceği
- Kaynak deposu bağlantılı ve erişilebilirhapitech/golivemcp-docs is public and reachablegithub.com/hapitech/golivemcp-docs ↗Geçti
- Paket, bu depoyu kaynağı olarak gösteriyorKontrol edilmedi
- Derleme kökeni (Sigstore onayı)Kontrol edilmedi
- Açık kaynak lisansı (OSI)MITspdx.org/licenses/MIT.html ↗Geçti
- Son bir yıl içinde commit veya sürüm mevcutLast commit or release 2026-10-31github.com/hapitech/golivemcp-docs ↗Geçti
- OpenSSF ScorecardKontrol edilmedi
- Paket adı popüler bir pakete yakın değilKontrol edilmedi
- Pakette veya bağımlılıklarında kritik uyarı yokKontrol edilmedi
- Modele yönelik gizli talimat yok0 tool descriptions and the README read; no override phrases, credential paths or hidden charactersGeçti
- Yıkıcı araçlar etiketlenmişKontrol edilmedi
- Uzak uç nokta MCP el sıkışmasına yanıt veriyorKontrol edilmedi
GoLive MCP
Your agents build. We help you go live.
GoLive MCP is a remote MCP server for the last mile of shipping software. A coding agent can
write the app; GoLive gives it the rest as tools: check and buy a domain inside a budget, manage
DNS, set up email on the domain, deploy from a GitHub repo, set environment variables and rotate
secrets without ever reading them back, create buckets and volumes, route a hostname to the app and
check its certificate, send SMS and WhatsApp, call AI models with no provider key of its own
(text, JSON that matches a schema, and classification, billed per token; recommend_model picks
the model and prices it), and run security, privacy and regulation audits before launch.
- Endpoint (Streamable HTTP):
https://golivemcp.com/mcp - Website: https://golivemcp.com
- Tool registry (JSON): https://golivemcp.com/tools.json
- Official MCP Registry:
com.golivemcp/golive - Auth: OAuth 2.1 (dynamic client registration, PKCE) or an API key in
x-api-key/Authorization: Bearer. Invite-only beta.
This repository holds documentation only. The server is hosted; there is nothing to install.
Connect
Claude Code:
claude mcp add --transport http golive https://golivemcp.com/mcp
Claude.ai or Claude Desktop: Settings, Connectors, Add custom connector, URL
https://golivemcp.com/mcp, then approve with your GoLive key.
Any MCP client:
{
"mcpServers": {
"golive": {
"type": "http",
"url": "https://golivemcp.com/mcp",
"headers": { "x-api-key": "glk_..." }
}
}
}
Clients that only speak stdio can bridge with npx mcp-remote https://golivemcp.com/mcp.
See llms-install.md.
Safety model
- Dry run first. Every tool that changes something accepts
dry_run: trueand returns the plan. - Confirm the target. Destructive and spending tools need
confirmset to the exact target. - Budgets default to zero. Buying or provisioning needs an operator-opened budget with an amount, a per-action cap and an expiry. Agents cannot open or widen one.
- Secrets go in, never out. Tools answer with names, lengths and the last 4 characters.
- No keys handed over. Registrar, cloud and DNS credentials stay inside the platform.
- Every attempt is audited, refusals included (
audit_log).
Example requests
- "Is launchpad.dev available, and what would it cost? Plan the purchase but don't buy it."
- "Deploy acme/launchpad from main and tell me when it is live."
- "Set STRIPE_SECRET_KEY on launchpad and redeploy."
- "Route launchpad.dev to the launchpad app and check its certificate."
- "Run a security audit and a privacy and regulation audit on https://github.com/acme/launchpad."
- "Which model should launchpad use to route support emails to billing, bugs or sales, and what will 500 a day cost?"
- "Give launchpad model access so the app can extract invoice fields at runtime."
Tools
Some tools are marked soon on https://golivemcp.com while their platform routes ship; they
answer capability_pending until then.
99 tools.
| Group | Tool | What it does |
|---|---|---|
| Domains | check_domain |
Is a domain available, and what does it cost to register and renew? Free, no side effects. |
| Domains | buy_domain |
Registers a domain and creates its Cloudflare zone. Spends money: needs a reason, confirm equal to the domain, and credit (a prepaid account with credit is never stopped by the shared domains budget; any other account needs an operator-opened one). Registered through GoLive's own registrar, with its DNS zone in GoLive's Cloudflare account and the nameservers set, so DNS, email and attach_domain work on it at once. Returns the domain and zone id, never a credential. |
| Domains | list_domains |
Domains (Cloudflare zones) registered to your account on GoLive, with their status. |
| Domains | domain_status |
Whether a domain's Cloudflare zone is active, and the nameservers it should point at. For a domain whose DNS stays at your own host, the routing and email setups registered on it (attach_domain, setup_domain_email), whether their required records are published, and any drift of a completed setup from its plan. |
| Domains | check_transfer |
Can a domain you own at another registrar move to GoLive, and what will it cost? Reads the registry (RDAP): registered or not, locked (clientTransferProhibited), created or last transferred under 60 days ago, and which registrar holds it; plus Porkbun's quote (price including one year, premium, and whether GoLive's registrar credit covers it). Refuses .uk, premium names and names under 60 days. Returns the steps at the current registrar (GoDaddy, Namecheap, Squarespace/Google, Cloudflare, Wix, or generic): unlock, turn privacy off, get the auth code. Free. |
| Domains | initiate_domain_transfer |
Moves a domain you own at another registrar to GoLive (Porkbun), so GoLive manages its DNS, email and renewals. Owner only (the account's admin-scoped key). SPENDS MONEY: the transfer price (it adds a year), held now, charged when the transfer completes and released if it is canceled; needs an open spend budget, a reason, and confirm equal to the domain. dry_run shows the exact price, the eligibility checks and the DNS records that will be copied. First the DNS is copied into a new zone in GoLive's Cloudflare account (from zone_file if you give the old host's export, otherwise by looking up the usual names publicly plus dns_names); the nameservers do not change until the transfer is done and the copy matches. The auth code is a secret: it goes to the registrar only and is never stored, logged or returned. At most 5 a day per account, one live transfer per domain. |
| Domains | confirm_domain_transfer |
Moves a transfer forward. While pending: reads its status from the registrar and says in plain words what is blocking it; a corrected auth_code replaces the old one (no second charge); approving at the old registrar skips the ~5-day wait. When done: charges the held price, registers the domain and its GoLive zone to your account, turns on auto-renew (the registrar locks it), and, with move_dns, compares the live DNS answers with the GoLive zone and only then points the nameservers at it; otherwise it lists the differences. Free. |
| Domains | cancel_domain_transfer |
Cancels a pending transfer before the old registrar releases the domain: the registrar withdraws it at the registry and refunds it, and the hold on your account is released. The domain stays where it was. Confirm with the domain. Free. |
| Domains | schedule_domain_transfer |
Moves a domain you own at another registrar to GoLive before it expires there, without you being around on the day. Owner only (the account's admin-scoped key). GoLive reads the expiry date from the registry and starts the transfer lead_days before it (default 30), exactly as initiate_domain_transfer would: on that date the price is held from your account and an open spend budget is needed. Nothing is held or charged now. Needs a reason and confirm equal to the domain; refused if the domain could not be transferred, or if the date has already passed (use initiate_domain_transfer then). A 60-day lock that ends before the date is fine. GoLive re-reads the expiry daily (a renewal moves the date), checks the stored code with a free dry run the day before, retries daily if the start fails, and gives up 2 days before expiry; you are told each time. The auth code is stored sealed (AES-256-GCM) until the transfer is started, canceled or given up, then wiped; it is never shown, logged or audited. Call again with a new auth_code to replace it. The schedule acts with the key that made it: if that key is revoked, the schedule fails and its code is wiped. Free. |
| Domains | list_scheduled_transfers |
Your scheduled transfers: for each, the domain, its expiry date, the date the transfer starts, its status (scheduled, claimed while it is being started, submitted, canceled, missed, failed), the last daily check, what went wrong last, warnings (such as no spend budget open on the date) and what you were told. Never the auth code. Free. |
| Domains | cancel_scheduled_transfer |
Owner only: removes a scheduled transfer before its date and wipes the stored auth code. Nothing was held, so nothing is released. A transfer already started is canceled with cancel_domain_transfer instead. Confirm with the domain. Free. |
| Domains | request_transfer_out |
Owner only: asks GoLive to release a domain you hold here so you can move it to another registrar. The operator unlocks it and emails the auth code to the registrant on file within 2 business days (Porkbun has no API for this yet). The request is recorded in the audit log. Free. |
| DNS | list_records |
DNS records of a zone registered to your account on GoLive, optionally filtered by name or type. |
| DNS | upsert_record |
Sets a DNS record on a zone on our Cloudflare account. By default the record of that name and type is REPLACED when there is exactly one, for A, AAAA, CNAME and the TXT policy records (SPF, DMARC, MTA-STS), so a new SPF string leaves no old one live; it is created when there is none, and a record with exactly this value is updated in place (ttl, proxied, priority). Refused, naming the record ids, when several of that name and type exist (pass mode: "add" to add another value, or delete the extras). Never replaced by default, refused with conflict instead: any other TXT (a verification token, DKIM, plain text), a TXT of another kind (an SPF record by a site verification, say), and MX, SRV and CAA, which are sets. Pass mode: "replace" to replace the one existing record (rotating a verification token), or mode: "add" to keep it and add this one. The dry run reads the records and says which of create, update, replace or add it would do. |
| DNS | delete_record |
Deletes one DNS record by id. Destructive: confirm with the record id. |
| DNS | verify_dns |
For a domain or hostname whose DNS stays at your own host (GoDaddy, Route 53, your own Cloudflare...): reads public DNS through two resolvers (Cloudflare 1.1.1.1 and Google, so propagation shows) and reports every record of the plan attach_domain or setup_domain_email gave you as present, missing, wrong or propagating, with the value expected, the value found and the exact fix; plus SPF problems (several SPF records, over 10 lookups) and conflicts (a CNAME at the root, old MX hosts). Nothing is created at a vendor until GoLive's ownership TXT (_golive.) is served by both resolvers; then it starts the setup (Railway custom domain, or the domain added to AI Mail). When every required record is present it completes the setup: the app's Railway custom domain and its certificate (re-added if it vanished), an HTTPS check (public addresses only), and AI Mail's verification (then the sending records AI Mail adds). Without setup it checks every setup on the name and its subdomains, and reports drift of a completed setup from its plan. Changes no DNS; safe to call repeatedly; complete: false only reports. Free; 20 per minute per account. |
| DNS | release_dns_setup |
Releases a routing or email setup that attach_domain or setup_domain_email registered for a name whose DNS stays at your own host: deletes the Railway custom domain GoLive created for it (the hostname stops being served by your app), or removes the domain from AI Mail when no other setup uses it (its mailboxes stop receiving), and forgets the plan. Changes no DNS: remove the records at your host yourself. Destructive: confirm with the name. Free. |
setup_domain_email |
Adds one of your domains (a zone registered to your account on GoLive) to AI Mail MCP and puts its DNS records in place: ownership, SPF, DKIM, DMARC and the sending provider's records, and MX when AI Mail's plan includes inbound records. On a zone in GoLive's own Cloudflare account GoLive writes them itself (GoLive-managed DNS), through the same checks as upsert_record, and never replaces or deletes a record that is there: a conflict (another SPF record, MX pointing elsewhere) is reported with what to do. Then AI Mail verifies the domain. Every answer says what AI Mail holds (pending or verified), each record's result, what is left, and how to finish (call again: every step is safe to repeat) or roll back. Inbound: on a GoLive zone (apex domain), once AI Mail has verified the domain GoLive turns on Cloudflare Email Routing for it and routes the zone's catch-all to GoLive's copy of AI Mail's receiver, so mail to any mailbox arrives directly; it never replaces MX pointing elsewhere or a catch-all that routes elsewhere (reported as a conflict), and undoes its own change if a step fails. Otherwise mail reaches a mailbox through its route address (the answer says which applies). A domain whose DNS stays at your own host (not a GoLive zone): GoLive changes no DNS. It registers a pending setup and returns GoLive's ownership TXT (_golive.) first, with AI Mail's records as a preview; nothing is added to AI Mail until both public resolvers show the ownership record. Then this call or verify_dns adds the domain and gives the exact records (AI Mail's ownership TXT, MX, SPF merged into the SPF you already publish, DKIM, DMARC; required or recommended, with hints for your host), and verify_dns completes it. Unproved setups are released after 7 days; release_dns_setup releases one. Free. | |
create_mailbox |
Creates a mailbox (e.g. hello@example.com) on one of your domains already set up for email (a zone registered to your account on GoLive, or a domain on your own DNS host whose setup_domain_email setup verify_dns completed). With app (an app on your account), the app also gets mail through AI Mail with no key to handle: GoLive mints an AI Mail token that can only send from this mailbox (200 a day) and writes AIMAIL_URL, AIMAIL_TOKEN and EMAIL_FROM on the app, then redeploys it once. The app sends by calling AI Mail's send_message at the AIMAIL_URL value + /mcp with AIMAIL_TOKEN as the bearer. The token is never shown. With app, a mailbox that already exists is reused, and calling again rotates the token (the previous one GoLive minted for that app and mailbox is revoked). Use this, not a separate email provider's key, for an app's transactional mail. | |
| Deploy | create_app |
Creates a new service that deploys from a GitHub repository branch, and registers it. The repo must be covered by this account's GitHub installation and the branch must exist; the repo is linked to the app. Natively it creates a Railway project with a Postgres database (database: none to skip), a generated hostname, and registers the app to your account as soon as the project exists. Safe to repeat: a retry continues a partly built app. Provisions a billable resource: needs an open resources budget. |
| Deploy | deploy |
Deploys the latest commit of the app's deploy branch (or a given commit), or with redeploy_current redeploys what is deployed now. When a GitHub repo is linked to the app, the deploy is GATED: it needs a passing preflight for that exact commit from the last 24 hours, is pinned to that commit, and a red-risk commit also needs confirm set to the full SHA. The app owner may override with override_preflight and a reason (audited). Without a linked repo the gate is skipped and the result says so. The answer carries the new deployment id and the commit it builds (for a branch-head deploy, the SHA the head resolved to, once Railway records it). |
| Deploy | deploy_status |
The current and recent deployments of an app: status, commit, and when. |
| Deploy | logs |
Recent runtime or build log lines of an app (up to 500), with secrets scrubbed server side: the app's own env values and anything shaped like a credential. |
| Deploy | rollback |
Redeploys the previous successful deployment (or a given one). The previous one is the newest deployment created before the live one that served, even while Railway is still removing it; if Railway cannot roll back to it, the call refuses and names it (with an older one you may pass) instead of reaching further back. The dry run names the target: id, commit and created time. Pass that id as deployment_id to act on exactly it; without deployment_id the real call applies the same rule again. Railway rolls back by creating a new deployment; the answer names it as deployment_id. Destructive: replaces what is live; confirm with the app id. |
| Deploy | restart |
Restarts the running deployment without rebuilding. |
| Config and secrets | set_env |
Sets one variable on an app and redeploys it (unless redeploy: false). The value goes in and is never echoed: the answer carries its length and, for values of 12 or more characters, the last 4. References (${{...}}) and Railway's own names (RAILWAY_*, PORT) are refused. Confirm with the variable name. |
| Config and secrets | list_env |
Variable NAMES on an app, each with its length and last 4 characters. Never values. |
| Config and secrets | unset_env |
Removes one variable from an app and redeploys it (unless redeploy: false), so the running app no longer sees it. The variable must exist; the dry run names it with its length and last 4 characters. Railway's own names (RAILWAY_*, PORT), DATABASE_URL and references (${{...}}) are refused. The answer names the redeploy as deployment_id. Confirm with the variable name. |
| Config and secrets | rotate_secret |
Generates a new random value for a variable that exists on an app (hex, from bytes random bytes, default 32) and writes it on the app's service and on any other service of the app holding the same value, then redeploys them and any service that references it (${{service.NAME}}), and checks it took. The value is generated server side and never returned: the answer carries its length and last 4 characters, as set_env does. The dry run names the variable and every service it would touch; the answer names the deployment each redeployed service gets (deployments). Railway's own names (RAILWAY_*, PORT), DATABASE_URL and references are refused. Confirm with the variable name. |
| Storage | create_bucket |
Creates an S3-compatible object storage bucket for an app. Provisions a billable resource: needs an open resources budget. |
| Storage | bucket_credentials |
Issues credentials scoped to one bucket and writes them straight into the app's environment. Returns the variable names only; the credentials never pass through the agent. |
| Storage | create_volume |
Creates a persistent disk and mounts it on the app. Provisions a billable resource: needs an open resources budget. |
| Storage | add_database |
Adds a Postgres (default) or Redis database to an existing app: Railway's template in the app's own project and environment, and a Railway reference to its connection variable on the app service (DATABASE_URL for postgres, REDIS_URL for redis), never a literal. Redeploys the app once so it sees the variable. The answer names the service, the engine and the variable, never a connection string. Refused when the app already has a database of that engine or the variable is already set. Safe to repeat: the database is requested once; a repeat while Railway is still creating it answers status provisioning (later stuck), and finishes the wiring when it is up. The dry run shows the steps and the estimated monthly price. Provisions a billable resource: needs an open resources budget. |
| Routing | attach_domain |
Routes a hostname to one of your apps: a Railway custom domain on the app (Railway serves TLS for it). On a zone GoLive hosts, GoLive also writes a proxied CNAME to Railway's target and Railway's verification TXT, never replacing an existing record. When the hostname is already this app's and Railway's certificate for it failed (ssl_status shows certificate failed), calling attach_domain again retries it: the Railway custom domain is re-created and its CNAME and TXT updated. On a domain whose DNS stays at your own host (GoDaddy, Route 53, your own Cloudflare...), GoLive changes no DNS: it registers a pending setup and returns the records to publish (type, name relative and full, value, TTL, required or recommended, with hints for your host and for a root domain, which needs CNAME flattening or ALIAS since Railway has no fixed IP). First comes GoLive's ownership TXT (_golive.): nothing is created at Railway until both public resolvers show it; then this call or verify_dns creates the Railway custom domain and gives its CNAME target and verification TXT, and verify_dns completes the setup. Unproved setups are released after 7 days; release_dns_setup releases one. Free. |
| Routing | ssl_status |
Whether a hostname serves valid HTTPS right now, plus its zone status; and, when the hostname is attached to one of your apps, Railway's own certificate for it (validating, issuing or valid). Cloudflare's edge answers HTTPS as soon as the proxied record exists, so the probe can pass before Railway's certificate is issued. A zone shared with you under a name scope shows its status, not the owner's zone-wide SSL settings. |
| Pre-deploy checks | validate_changes |
Diffs the commit to deploy (default: the head of the linked deploy branch) against the commit that is live, through GitHub's compare API, and rates the change red, yellow or green with reasons: destructive migrations (DROP, TRUNCATE, ALTER ... DROP) are red; other migrations, environment variables the new code reads but the app lacks (names only), dependency and lockfile changes, build and deploy config, auth code and large diffs are yellow. Honours golive.yaml in the repo (red_paths, green_paths, migration command), read at the live commit; and the risk.red_paths and risk.green_paths of a fleet harness manifest (.claude/harness.yaml). With both files, golive.yaml's settings apply and the red_paths of both (red never relaxes); a risk block GoLive cannot read makes the change red. For an app that carries BETTER_AUTH_URL or a Better Auth secret it adds a Better Auth section (names and lengths only): secret present and at least 32 characters (red otherwise), BETTER_AUTH_URL https (red) and an attached host (yellow), and, from lib/auth.ts or src/lib/auth.ts at the commit, rate limit storage 'database' (yellow) and requireEmailVerification: true when password sign-in is on (red). Nothing is executed. Stores a report. Free. |
| Pre-deploy checks | preflight |
Runs validate_changes, then reads the commit's CI in GitHub (Actions runs, other check suites and commit statuses). Passes when CI succeeded, or when the repo has no CI (noted). Stores one report tied to the exact commit; deploy needs a passing one from the last 24 hours. Called from inside a GitHub Actions workflow on the same commit, pass that run's id (GITHUB_RUN_ID) as ci_exclude_run_id so the calling run, still in progress, is left out; only an in-progress run of this repo and commit can be excluded, the report records it, and deploy re-reads CI for such a report (refusing if the excluded run has since failed). Free. |
| Pre-deploy checks | get_preflight_report |
Past validate_changes and preflight reports for an app, newest first, optionally for one commit (full or short SHA) or one kind. Free. |
| Audits | security_audit |
Starts a security audit (dependencies, secrets in code, auth, injection, headers) of a git repository (or, for the operator, an imagia project). Returns a report id for get_report. Tiered: the dry run shows the M-tier price that is held and the full schedule; the charge is the tier of the measured file count. repo_url audits answer capability_pending until imagia supports them. |
| Audits | compliance_audit |
Starts a compliance aud |
GoLive MCP soruları
Does the server require installation?
No, the server is hosted remotely and there is nothing to install locally.
How does GoLive handle sensitive information like secrets?
Secrets are designed to go in but never out; tools only return the name, length, and the last 4 characters of a secret.
Can I test actions before they are executed?
Yes, every tool that modifies state accepts a dry_run: true parameter which returns a plan instead of executing.