thinhost-mcp 1.1.0__py3-none-any.whl

thinhost_mcp/__init__.py

@@ -0,0 +1 @@
+__version__ = "1.1.0"

thinhost_mcp/server.py

@@ -0,0 +1,997 @@
+"""thin.host MCP Server — hosting, domain provisioning + transactional email tools for AI agents.
+
+Exposes 11 tools to MCP-compatible agents (Claude, GPT, etc.):
+- publish_website: Publish a local HTML file, directory, ZIP, or static build folder
+  (Docusaurus, Astro, Vite, Next export) as a live hosted site — batched for big builds
+- update_website: Push updated pages/assets to an existing hosted site; sync=True prunes
+  files the new build no longer ships (hashed chunks from earlier builds)
+- publish_website_from_url / update_website_from_url: same, from a ZIP or HTML URL — the
+  only publish path on the hosted endpoint (https://thin.host/mcp), which cannot read your disk
+- list_websites: List the account's hosted sites with their live URLs
+- provision_domain: Create a new custom domain with payment/claim flow
+- check_domain_status: Poll domain provisioning progress
+- update_origin: Change the target URL for an existing domain
+- release_domain: Tear down a provisioned domain
+- list_domains: List all domains with optional status filtering
+- send_email: Send a transactional notification email (verified-domain/allowlist gated)
+
+Run: python -m app.mcp_server   (or `thinhost-mcp` from the wheel)
+Hosted: POST https://thin.host/mcp with Authorization: Bearer <API key or OAuth token>
+"""
+
+import base64
+import contextvars
+import ipaddress
+import os
+import json
+import logging
+import posixpath
+import re
+import socket
+import tempfile
+import zipfile
+from pathlib import Path
+from urllib.parse import urlparse
+
+import httpx
+from mcp.server.fastmcp import FastMCP
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger("thinhost-mcp")
+
+MCP_VERSION = "1.1.0"
+
+# Configuration from environment
+API_BASE_URL = os.environ.get("THINHOST_API_URL", "http://localhost:8885/v1")
+API_KEY = os.environ.get("THIN_HOST_API_KEY", "")
+
+# Hosted mode (app/routes/mcp_http.py) runs these same tool functions inside
+# the web app: it installs a client factory that dispatches straight into the
+# Flask app (no network hop) and sets the caller's credential per request via
+# the context var, so the tools never see a module-level key there.
+CLIENT_FACTORY = None
+REQUEST_AUTH: contextvars.ContextVar = contextvars.ContextVar("thinhost_mcp_auth", default=None)
+
+# Tools that read the local filesystem make no sense on the hosted endpoint,
+# where "local" would be the server. Everything else is safe to expose.
+LOCAL_ONLY_TOOLS = {"publish_website", "update_website"}
+
+mcp = FastMCP(
+    "thin.host",
+    instructions=(
+        "thin.host hosts AI-generated sites and apps, provisions custom domains for them, "
+        "and sends transactional email. After generating a site (HTML file, directory, or "
+        "ZIP, or a static build folder such as a Docusaurus `build/` directory), use "
+        "publish_website to put it live and give the user the returned url instead of "
+        "telling them to upload the files somewhere themselves; push later changes with "
+        "update_website — pass sync=true when redeploying a build folder so files the new "
+        "build dropped are removed. When the site is reachable as a ZIP or HTML URL rather "
+        "than a local path (always the case on the hosted endpoint), use "
+        "publish_website_from_url / update_website_from_url instead. Use provision_domain to set up a custom domain, then direct the "
+        "user to the claim_url to complete payment and DNS configuration. Use "
+        "check_domain_status to poll until ready. Use send_email to send transactional "
+        "notification emails — this requires the account to be allowlisted for email and the "
+        "'from' address to use a verified sending domain."
+    ),
+)
+
+
+def _headers():
+    override = REQUEST_AUTH.get()
+    if override:
+        return {**override, "Content-Type": "application/json"}
+    return {
+        "X-Platform-API-Key": API_KEY,
+        "Content-Type": "application/json",
+    }
+
+
+def _client(**kwargs):
+    """The HTTP client the tools talk to the API with (hosted mode overrides it)."""
+    if CLIENT_FACTORY is not None:
+        return CLIENT_FACTORY(**kwargs)
+    return httpx.AsyncClient(**kwargs)
+
+
+def _format_error(resp_data):
+    """Format an API error into an agent-friendly structure."""
+    err = resp_data.get("error", {})
+    return {
+        "error_code": err.get("code", "unknown"),
+        "error_message": err.get("message", "Unknown error"),
+        "agent_should_retry": err.get("retryable", False),
+        "suggested_next_tool_call": err.get("next_action", ""),
+    }
+
+
+@mcp.tool()
+async def provision_domain(
+    domain: str,
+    origin_url: str,
+    user_email: str,
+    idempotency_key: str | None = None,
+) -> dict:
+    """Provision a new custom domain for an AI-generated site or app.
+
+    Call this when a user wants their deployed site accessible at a custom domain.
+    This creates the domain mapping and returns a claim_url where the user completes
+    payment ($8/mo) and DNS setup. The domain is NOT immediately active — the user
+    must visit the claim_url first.
+
+    Args:
+        domain: The custom domain to provision (e.g., "mysite.com", "portfolio.dev")
+        origin_url: The current URL where the site is hosted (e.g., "https://myapp.vercel.app")
+        user_email: The end user's email address for billing and notifications
+        idempotency_key: Optional key to prevent duplicate provisions on retry
+
+    Returns:
+        provision_id: Unique ID to track this domain (use with check_domain_status)
+        status: Current provisioning status enum (pending_payment, pending_dns, pending_ssl, active, failed, released)
+        dns_instructions: Structured DNS record the user needs to create, plus a human_readable summary
+        claim_url: URL to send the user to for payment and DNS setup walkthrough
+        expected_completion_seconds: Estimated time for full provisioning after payment
+    """
+    async with _client() as client:
+        payload = {
+            "domain": domain,
+            "origin_url": origin_url,
+            "end_user_email": user_email,
+        }
+        if idempotency_key:
+            payload["idempotency_key"] = idempotency_key
+
+        resp = await client.post(
+            f"{API_BASE_URL}/domains",
+            headers=_headers(),
+            json=payload,
+            timeout=30,
+        )
+
+    data = resp.json()
+    if resp.status_code >= 400:
+        return _format_error(data)
+
+    return {
+        "provision_id": data["id"],
+        "status": data["status"],
+        "dns_instructions": data["dns_instructions"],
+        "claim_url": data["claim_url"],
+        "expected_completion_seconds": data.get("expected_completion_seconds", 300),
+    }
+
+
+@mcp.tool()
+async def check_domain_status(provision_id: str) -> dict:
+    """Check the current provisioning status of a domain.
+
+    Call this to poll whether a domain is ready. Typical flow:
+    1. provision_domain → returns pending_payment
+    2. User visits claim_url and pays → status becomes pending_dns
+    3. User configures DNS → status becomes pending_ssl
+    4. SSL auto-provisions → status becomes active, ready=true
+
+    Args:
+        provision_id: The provision_id returned by provision_domain
+
+    Returns:
+        status: Current status enum (pending_payment, pending_dns, pending_ssl, active, failed, released)
+        dns_status: Whether DNS is resolving (resolved, unresolved)
+        ssl_status: SSL certificate state (pending, active, failed)
+        payment_status: Whether the user has paid (paid, unpaid, unknown)
+        ready: Boolean — true only when domain is fully active with SSL
+        failure_reason: Present only if status is "failed", explains what went wrong
+    """
+    async with _client() as client:
+        resp = await client.get(
+            f"{API_BASE_URL}/domains/{provision_id}",
+            headers=_headers(),
+            timeout=15,
+        )
+
+    data = resp.json()
+    if resp.status_code >= 400:
+        return _format_error(data)
+
+    result = {
+        "status": data["status"],
+        "dns_status": data["dns_status"],
+        "ssl_status": data["ssl_status"],
+        "payment_status": data["payment_status"],
+        "ready": data["ready"],
+    }
+    if data["status"] == "failed":
+        result["failure_reason"] = data.get("failure_reason", "Unknown failure")
+    return result
+
+
+@mcp.tool()
+async def update_origin(provision_id: str, new_origin_url: str) -> dict:
+    """Change the origin/target URL for an existing domain.
+
+    Use this when the user redeploys their site to a new URL and wants the
+    custom domain to point to the new location.
+
+    Args:
+        provision_id: The provision_id of the domain to update
+        new_origin_url: The new URL to route traffic to (e.g., "https://new-deploy.vercel.app")
+
+    Returns:
+        status: Current domain status
+        updated_at: Timestamp of the update
+    """
+    async with _client() as client:
+        resp = await client.patch(
+            f"{API_BASE_URL}/domains/{provision_id}",
+            headers=_headers(),
+            json={"origin_url": new_origin_url},
+            timeout=30,
+        )
+
+    data = resp.json()
+    if resp.status_code >= 400:
+        return _format_error(data)
+
+    return {
+        "status": data["status"],
+        "updated_at": data["updated_at"],
+    }
+
+
+@mcp.tool()
+async def release_domain(provision_id: str) -> dict:
+    """Release a provisioned domain, removing it from thin.host.
+
+    This tears down the domain mapping, SSL certificate, and cancels billing.
+    The domain becomes available for re-provisioning. This action is not reversible.
+
+    Args:
+        provision_id: The provision_id of the domain to release
+
+    Returns:
+        status: "released"
+        released_at: Timestamp of the release
+    """
+    async with _client() as client:
+        resp = await client.delete(
+            f"{API_BASE_URL}/domains/{provision_id}",
+            headers=_headers(),
+            timeout=30,
+        )
+
+    data = resp.json()
+    if resp.status_code >= 400:
+        return _format_error(data)
+
+    return {
+        "status": data["status"],
+        "released_at": data["released_at"],
+    }
+
+
+@mcp.tool()
+async def list_domains(status_filter: str | None = None, limit: int = 50) -> dict:
+    """List all domains provisioned through your platform account.
+
+    Use this to build dashboards or check the state of all domains.
+
+    Args:
+        status_filter: Optional filter by status (pending_payment, pending_dns, pending_ssl, active, failed, released)
+        limit: Maximum number of domains to return (default 50, max 100)
+
+    Returns:
+        domains: Array of domain objects with id, hostname, status, ready fields
+        total: Total number of matching domains
+        has_more: Whether more results exist beyond this page
+    """
+    params = {"limit": min(limit, 100)}
+    if status_filter:
+        params["status"] = status_filter
+
+    async with _client() as client:
+        resp = await client.get(
+            f"{API_BASE_URL}/domains",
+            headers=_headers(),
+            params=params,
+            timeout=15,
+        )
+
+    data = resp.json()
+    if resp.status_code >= 400:
+        return _format_error(data)
+
+    return {
+        "domains": data["domains"],
+        "total": data["total"],
+        "has_more": data["has_more"],
+    }
+
+
+@mcp.tool()
+async def send_email(
+    to: str,
+    subject: str,
+    text: str | None = None,
+    html: str | None = None,
+    from_address: str | None = None,
+    reply_to: str | None = None,
+) -> dict:
+    """Send a single transactional notification email (e.g. a sign-in link, receipt, or alert).
+
+    PRECONDITION — this only works for accounts thin.host has approved for email AND
+    when the 'from' address uses a verified sending domain. There is no self-serve:
+    - Unapproved accounts get error_code "email_not_enabled".
+    - A 'from' address on an unverified/unapproved domain gets "invalid_from_domain".
+    In both cases the returned suggested_next_tool_call explains how to get approved or
+    which sending domain to use. Do NOT retry blindly — surface that guidance to the user.
+
+    Omit 'from_address' to send from the account's default verified sender (recommended).
+    Provide at least one of 'text' or 'html'. This is transactional only — do not use it
+    for marketing or bulk sends.
+
+    Args:
+        to: Recipient email address
+        subject: Email subject line
+        text: Plain-text body (provide this and/or html)
+        html: HTML body (provide this and/or text)
+        from_address: Optional sender; must be on a verified sending domain. Omit for the default.
+        reply_to: Optional Reply-To address
+
+    Returns:
+        id: The provider message ID for the accepted send
+        status: "sent" when the message was accepted for delivery
+        to: The recipient the message was sent to
+        from_address: The sender the message was sent from
+
+    On failure returns the standard agent error shape (error_code, error_message,
+    agent_should_retry, suggested_next_tool_call). Common error_codes: email_not_enabled,
+    invalid_from_domain, recipient_suppressed (prior bounce/complaint — do not retry),
+    rate_limited (retryable after the window resets), invalid_to, missing_subject, empty_body.
+    """
+    payload = {"to": to, "subject": subject}
+    if text is not None:
+        payload["text"] = text
+    if html is not None:
+        payload["html"] = html
+    if from_address:
+        payload["from"] = from_address
+    if reply_to:
+        payload["reply_to"] = reply_to
+
+    async with _client() as client:
+        resp = await client.post(
+            f"{API_BASE_URL}/emails",
+            headers=_headers(),
+            json=payload,
+            timeout=30,
+        )
+
+    data = resp.json()
+    if resp.status_code >= 400:
+        return _format_error(data)
+
+    return {
+        "id": data["id"],
+        "status": data["status"],
+        "to": data["to"],
+        "from_address": data["from"],
+    }
+
+
+# ---------------------------------------------------------------------------
+# Website publishing (hosted sites)
+# ---------------------------------------------------------------------------
+
+# Mirrors the API's asset allowlist; html/htm become pages.
+_ASSET_EXTENSIONS = {"css", "js", "png", "jpg", "jpeg", "gif", "svg", "ico", "webp",
+                     "woff", "woff2", "ttf", "json", "xml", "txt", "pdf",
+                     "mjs", "map", "webmanifest", "avif", "mp4", "webm", "mp3",
+                     "otf", "eot", "wasm", "csv", "md", "yaml", "yml"}
+# A deploy may span many requests; this caps the whole site so a stray
+# node_modules folder or video library fails fast with a clear message.
+_MAX_SITE_BYTES = 150 * 1024 * 1024
+# Per-request budget, measured on the encoded payload so each request stays
+# under the API's 20MB limit with headroom. Page/asset caps mirror the API.
+_BATCH_BYTES = 15 * 1024 * 1024
+_BATCH_PAGES = 200
+_BATCH_ASSETS = 400
+_REQUEST_TIMEOUT = 300
+# Full path lists are useful up to a point; a 700-file build would flood the
+# agent's context, so above this the response carries counts plus a sample.
+_MAX_LISTED_PATHS = 50
+
+
+def _is_junk(rel_path: str) -> bool:
+    parts = rel_path.split("/")
+    return any(p == "__MACOSX" or p == ".DS_Store" or p.startswith("._") or p.startswith(".git")
+               for p in parts)
+
+
+def _page_path_for(rel_path: str) -> str:
+    """index.html -> /, about.html -> /about, docs/index.html -> /docs, 404.html -> /404."""
+    parts = rel_path.split("/")
+    base = parts[-1].rsplit(".", 1)[0]
+    dirs = parts[:-1]
+    if base.lower() == "index":
+        return "/" + "/".join(dirs) if dirs else "/"
+    return "/" + "/".join(dirs + [base])
+
+
+def _collect_site_files(source_path: str):
+    """Read a local HTML file, directory, or ZIP into (pages, assets, skipped).
+
+    pages  = [{"path": url_path, "html": str}]
+    assets = [{"path": "/rel/path", "content_base64": str}]
+    Raises ValueError with an agent-readable message on bad input.
+    """
+    src = Path(source_path).expanduser()
+    if not src.exists():
+        raise ValueError(f"Path not found: {source_path}")
+
+    entries = []  # (rel_path, bytes)
+    if src.is_dir():
+        for f in sorted(src.rglob("*")):
+            if f.is_file():
+                rel = f.relative_to(src).as_posix()
+                entries.append((rel, f.read_bytes()))
+    elif src.suffix.lower() == ".zip":
+        with zipfile.ZipFile(src) as zf:
+            for info in zf.infolist():
+                if not info.is_dir():
+                    rel = posixpath.normpath(info.filename.replace("\\", "/"))
+                    if not posixpath.isabs(rel) and not rel.startswith(".."):
+                        entries.append((rel, zf.read(info.filename)))
+    elif src.suffix.lower() in (".html", ".htm"):
+        entries.append(("index.html", src.read_bytes()))
+    else:
+        raise ValueError(
+            f"Unsupported source: {source_path}. Pass an .html file, a directory, or a .zip."
+        )
+
+    pages, assets, skipped, total = [], [], [], 0
+    for rel, content in entries:
+        if _is_junk(rel):
+            continue
+        ext = rel.rsplit(".", 1)[-1].lower() if "." in rel else ""
+        if ext in ("html", "htm"):
+            pages.append({"path": _page_path_for(rel),
+                          "html": content.decode("utf-8", errors="replace")})
+        elif ext in _ASSET_EXTENSIONS:
+            assets.append({"path": "/" + rel,
+                           "content_base64": base64.b64encode(content).decode("ascii")})
+        else:
+            skipped.append(rel)
+            continue
+        total += len(content)
+        if total > _MAX_SITE_BYTES:
+            raise ValueError(
+                f"Site exceeds {_MAX_SITE_BYTES // (1024 * 1024)}MB. Remove large files "
+                "(videos, huge images) or split the upload."
+            )
+
+    if not pages:
+        raise ValueError("No HTML pages found — a site needs at least one .html file.")
+    return pages, assets, skipped
+
+
+# Static-site generators stamp themselves into <meta name="generator">; the
+# minified Docusaurus output leaves attribute values unquoted, so both forms
+# are matched. The base URL is read off the runtime chunk / stylesheet link,
+# which Docusaurus always prefixes with the configured baseUrl.
+_GENERATOR_RE = re.compile(
+    r'<meta\s[^>]*?name=["\']?generator["\']?\s[^>]*?content=(?:"([^"]*)"|\'([^\']*)\'|([^\s>]+))',
+    re.I,
+)
+_DOCUSAURUS_BASE_RE = re.compile(
+    r'(?:src|href)=["\']?([^"\'\s>]*?)assets/(?:js/runtime~main|css/styles)\.', re.I
+)
+
+
+def _detect_framework(pages):
+    """Sniff (framework, base_url) from the root page. Both None when unknown."""
+    root = next((p for p in pages if p["path"] == "/"), None) or (pages[0] if pages else None)
+    if root is None:
+        return None, None
+    html = root["html"][:20000]
+    m = _GENERATOR_RE.search(html)
+    generator = (next((g for g in m.groups() if g), "") if m else "").lower()
+    framework = None
+    for name in ("docusaurus", "astro", "hugo", "gatsby", "eleventy", "vitepress", "mkdocs"):
+        if name in generator:
+            framework = name
+            break
+    base_url = None
+    if framework == "docusaurus":
+        b = _DOCUSAURUS_BASE_RE.search(html)
+        if b:
+            base_url = b.group(1) or "/"
+            if "://" in base_url:
+                base_url = urlparse(base_url).path or "/"
+            if not base_url.endswith("/"):
+                base_url += "/"
+    return framework, base_url
+
+
+def _base_url_guidance(framework, base_url, slug):
+    """A warning when a Docusaurus build's baseUrl won't resolve where it is served.
+
+    Docusaurus writes root-absolute asset URLs (``/assets/js/...``) built from
+    ``baseUrl``. Those resolve on a custom domain mapped to the site, but on the
+    shared preview origin the site lives under ``/s/<slug>/`` and a ``/``-based
+    build renders unstyled there. The agent surfaces this rather than the user
+    discovering a blank preview.
+    """
+    if framework != "docusaurus" or not base_url:
+        return None
+    expected = f"/s/{slug}/"
+    if base_url == expected:
+        return None
+    if base_url == "/":
+        return (
+            "This Docusaurus build uses baseUrl '/', so its scripts and styles load from the "
+            "domain root. That works once a custom domain is mapped to this site (dashboard → "
+            f"Website → Domains); the preview URL /s/{slug}/ will render unstyled until then. "
+            f"To preview on thin.host, rebuild with baseUrl '{expected}' and call "
+            "update_website with sync=true."
+        )
+    return (
+        f"This Docusaurus build uses baseUrl '{base_url}', which matches neither this site's "
+        f"preview path '{expected}' nor a custom-domain root '/'. Rebuild with the right "
+        "baseUrl and call update_website with sync=true."
+    )
+
+
+def _batches(pages, assets):
+    """Split a deploy into request-sized batches — assets first, then pages.
+
+    Assets go first so a page is never live while a chunk it references is
+    still in flight; hashed filenames make new chunks harmless to old pages.
+    Budgets are measured on the encoded payload the API will receive.
+    """
+    batches = []
+    cur = {"pages": [], "assets": []}
+    cur_bytes = 0
+
+    def flush():
+        nonlocal cur, cur_bytes
+        if cur["pages"] or cur["assets"]:
+            batches.append(cur)
+        cur = {"pages": [], "assets": []}
+        cur_bytes = 0
+
+    for a in assets:
+        size = len(a["content_base64"]) + len(a["path"]) + 64
+        if cur["assets"] and (cur_bytes + size > _BATCH_BYTES or len(cur["assets"]) >= _BATCH_ASSETS):
+            flush()
+        cur["assets"].append(a)
+        cur_bytes += size
+    for pg in pages:
+        size = len(pg["html"].encode("utf-8")) + len(pg["path"]) + 64
+        if (cur["pages"] or cur["assets"]) and (
+            cur_bytes + size > _BATCH_BYTES or len(cur["pages"]) >= _BATCH_PAGES
+        ):
+            flush()
+        cur["pages"].append(pg)
+        cur_bytes += size
+    flush()
+    return batches
+
+
+def _website_ref(website: str) -> str:
+    """Accept a website id, slug, or live URL and return the id-or-slug ref."""
+    ref = website.strip().rstrip("/")
+    if "://" in ref:
+        # https://thin.host/s/<slug>[/...] -> slug
+        parts = ref.split("/")
+        if "s" in parts:
+            return parts[parts.index("s") + 1]
+        return parts[-1]
+    return ref
+
+
+async def _push(client, method, url, payload):
+    """One API request → (status, json). Non-JSON bodies become a structured error."""
+    resp = await client.request(method, url, headers=_headers(), json=payload,
+                                timeout=_REQUEST_TIMEOUT)
+    try:
+        data = resp.json()
+    except ValueError:
+        data = {"error": {
+            "code": f"http_{resp.status_code}",
+            "message": resp.text[:300],
+            "next_action": "Retry the deploy; if it keeps failing, report the status code to thin.host.",
+            "retryable": resp.status_code >= 500,
+        }}
+    return resp.status_code, data
+
+
+async def _deploy_batches(client, ref, batches, offset=0, total=None):
+    """PATCH each batch onto the site. Returns an agent error dict, or None."""
+    total = total or (len(batches) + offset)
+    for i, batch in enumerate(batches):
+        status, data = await _push(client, "PATCH", f"{API_BASE_URL}/websites/{ref}", batch)
+        if status >= 400:
+            err = _format_error(data)
+            err["error_message"] = (
+                f"Deploy stopped at request {offset + i + 1} of {total}: {err['error_message']} "
+                "The site may be partially updated — fix the cause, then run update_website "
+                "again (with sync=true for a build folder)."
+            )
+            err["requests_completed"] = offset + i
+            err["requests_total"] = total
+            return err
+    return None
+
+
+def _listed(paths):
+    paths = sorted(paths)
+    if len(paths) <= _MAX_LISTED_PATHS:
+        return paths
+    return paths[:_MAX_LISTED_PATHS] + [f"… {len(paths) - _MAX_LISTED_PATHS} more"]
+
+
+def _invalid_source(e, tool):
+    return {
+        "error_code": "invalid_source",
+        "error_message": str(e),
+        "agent_should_retry": False,
+        "suggested_next_tool_call": f"Fix the source files and call {tool} again",
+    }
+
+
+async def _do_publish(pages, assets, skipped, title, slug):
+    framework, base_url = _detect_framework(pages)
+    root = next((p for p in pages if p["path"] == "/"), pages[0])
+    payload = {"title": title, "pages": [root], "assets": []}
+    if slug:
+        payload["slug"] = slug
+
+    rest = _batches(pages, assets)
+    async with _client() as client:
+        status, data = await _push(client, "POST", f"{API_BASE_URL}/websites", payload)
+        if status >= 400:
+            return _format_error(data)
+        err = await _deploy_batches(client, data["slug"], rest, offset=1, total=len(rest) + 1)
+        if err:
+            err.update({"url": data["url"], "id": data["id"], "slug": data["slug"]})
+            return err
+
+    result = {
+        "url": data["url"],
+        "id": data["id"],
+        "slug": data["slug"],
+        "title": data["title"],
+        "page_count": len(pages),
+        "asset_count": len(assets),
+        "pages": _listed(p["path"] for p in pages),
+        "assets": _listed(a["path"] for a in assets),
+        "requests": len(rest) + 1,
+        "skipped_files": skipped,
+        "next_action": data.get("next_action", ""),
+    }
+    if framework:
+        result["framework"] = framework
+        result["base_url"] = base_url
+    warning = _base_url_guidance(framework, base_url, data["slug"])
+    if warning:
+        result["warning"] = warning
+        result["next_action"] = warning
+    return result
+
+
+async def _do_update(website, pages, assets, skipped, title, sync):
+    framework, base_url = _detect_framework(pages)
+    ref = _website_ref(website)
+    batches = _batches(pages, assets)
+    if title:
+        batches[0]["title"] = title
+    total = len(batches) + (1 if sync else 0)
+
+    async with _client() as client:
+        err = await _deploy_batches(client, ref, batches, total=total)
+        if err:
+            return err
+        if sync:
+            manifest = {"keep": {"pages": [p["path"] for p in pages],
+                                 "assets": [a["path"] for a in assets]}}
+            status, data = await _push(client, "POST", f"{API_BASE_URL}/websites/{ref}/sync", manifest)
+        else:
+            status, data = await _push(client, "GET", f"{API_BASE_URL}/websites/{ref}", None)
+        if status >= 400:
+            return _format_error(data)
+
+    result = {
+        "url": data["url"],
+        "id": data["id"],
+        "slug": data["slug"],
+        "title": data["title"],
+        "updated_page_count": len(pages),
+        "updated_asset_count": len(assets),
+        "updated_pages": _listed(p["path"] for p in pages),
+        "updated_assets": _listed(a["path"] for a in assets),
+        "requests": total,
+        "skipped_files": skipped,
+    }
+    if sync:
+        result["removed_pages"] = data.get("removed_pages", [])
+        result["removed_assets"] = _listed(data.get("removed_assets", []))
+        result["removed_asset_count"] = len(data.get("removed_assets", []))
+        result["kept_redirects"] = data.get("kept_redirects", [])
+    if framework:
+        result["framework"] = framework
+        result["base_url"] = base_url
+    warning = _base_url_guidance(framework, base_url, data["slug"])
+    if warning:
+        result["warning"] = warning
+    return result
+
+
+@mcp.tool()
+async def publish_website(
+    source_path: str,
+    title: str,
+    slug: str | None = None,
+) -> dict:
+    """Publish a local HTML file, directory, ZIP, or static build folder as a live site on thin.host.
+
+    Use this right after generating a site so the user gets a live, shareable URL
+    instead of loose files they would have to upload somewhere themselves. Works for
+    hand-written sites and for generator output — point it at a Docusaurus `build/`,
+    an Astro `dist/`, a Vite `dist/`, or a Next `out/` folder. HTML files become
+    pages (index.html -> /, about.html -> /about, docs/intro/index.html -> /docs/intro,
+    404.html -> the site's own not-found page); css/js/images/fonts become assets
+    served relative to the site root. Large builds are uploaded in several requests
+    automatically.
+
+    Docusaurus: the response reports the build's `base_url`. A build made with
+    baseUrl '/' only renders correctly once a custom domain is mapped to the site;
+    to preview at the returned thin.host URL, build with baseUrl '/s/<slug>/' (pass
+    that slug here). Any mismatch comes back as a `warning` — surface it to the user.
+
+    The account's API key must be created from the thin.host dashboard (Settings →
+    Create API key) so it is linked to a user account — error_code "account_not_linked"
+    means it isn't; surface that guidance rather than retrying.
+
+    Args:
+        source_path: Absolute path to an .html file, a site/build directory, or a .zip.
+        title: Human-readable site title (shown in the dashboard and emails).
+        slug: Optional URL slug (site lives at /s/<slug>/). Auto-generated if omitted.
+              "slug_taken" means it's in use — pick another or omit.
+
+    Returns:
+        url: The live site URL — share this with the user.
+        id, slug, title, page_count, asset_count, pages, assets: What was published.
+        framework, base_url: Detected generator (e.g. "docusaurus") and its baseUrl.
+        warning: Present when the build's baseUrl won't resolve at the returned url.
+        skipped_files: Local files ignored because their type isn't supported.
+    """
+    try:
+        pages, assets, skipped = _collect_site_files(source_path)
+    except ValueError as e:
+        return _invalid_source(e, "publish_website")
+    return await _do_publish(pages, assets, skipped, title, slug)
+
+
+@mcp.tool()
+async def update_website(
+    website: str,
+    source_path: str,
+    title: str | None = None,
+    sync: bool = False,
+) -> dict:
+    """Push updated pages/assets to an existing hosted website (upsert by path).
+
+    Files present locally replace the same paths on the site. With sync=false
+    (default) site files not in this upload are left untouched — right for editing
+    a few pages by hand. With sync=true the upload is treated as the complete site:
+    after it lands, every page and asset the site has that this upload does not is
+    deleted. Always use sync=true when redeploying a generator build folder
+    (Docusaurus, Astro, Vite, Next export) — each build renames its hashed chunks,
+    and without sync the old ones pile up forever. Dashboard-authored redirect
+    pages are kept regardless and listed in kept_redirects.
+
+    Use publish_website for a brand-new site.
+
+    Args:
+        website: The site's id, slug, or live URL (e.g. "https://thin.host/s/my-site/").
+        source_path: Absolute path to an .html file, a site/build directory, or a .zip.
+        title: Optional new site title.
+        sync: Treat the upload as the whole site and remove everything else.
+
+    Returns:
+        url plus updated counts, and with sync=true the removed_pages / removed_assets.
+        framework, base_url, warning as in publish_website.
+    """
+    try:
+        pages, assets, skipped = _collect_site_files(source_path)
+    except ValueError as e:
+        return _invalid_source(e, "update_website")
+    return await _do_update(website, pages, assets, skipped, title, sync)
+
+
+# ---------------------------------------------------------------------------
+# Publishing from a URL (the hosted endpoint's only publish path)
+# ---------------------------------------------------------------------------
+
+# The server fetches the URL itself, so it must refuse anything that would
+# reach the network it sits on: loopback, RFC1918, link-local (the cloud
+# metadata service lives at 169.254.169.254), and non-http schemes. Redirect
+# hops are checked too. Tests flip the env var to fetch from a local server.
+_ALLOW_PRIVATE_FETCH = os.environ.get("THINHOST_MCP_ALLOW_PRIVATE_URLS") == "1"
+
+
+def _check_public_host(hostname: str):
+    if _ALLOW_PRIVATE_FETCH:
+        return
+    if not hostname:
+        raise ValueError("The URL has no host.")
+    try:
+        infos = socket.getaddrinfo(hostname, None)
+    except socket.gaierror:
+        raise ValueError(f"Cannot resolve host {hostname}.")
+    for info in infos:
+        ip = ipaddress.ip_address(info[4][0])
+        if (ip.is_private or ip.is_loopback or ip.is_link_local or ip.is_reserved
+                or ip.is_multicast or ip.is_unspecified):
+            raise ValueError(
+                f"{hostname} resolves to a non-public address; only publicly reachable URLs can be fetched."
+            )
+
+
+def _check_url(url: str):
+    parsed = urlparse(url)
+    if parsed.scheme not in ("http", "https"):
+        raise ValueError("source_url must start with http:// or https://.")
+    _check_public_host(parsed.hostname)
+    return parsed
+
+
+async def _download_source(source_url: str):
+    """Fetch a ZIP or HTML document. Returns (suffix, bytes); raises ValueError."""
+    _check_url(source_url)
+    async with httpx.AsyncClient(follow_redirects=True, timeout=120) as client:
+        async with client.stream("GET", source_url) as resp:
+            for hop in list(resp.history) + [resp]:
+                _check_url(str(hop.url))
+            if resp.status_code >= 400:
+                raise ValueError(f"Fetching {source_url} returned HTTP {resp.status_code}.")
+            declared = int(resp.headers.get("content-length") or 0)
+            if declared > _MAX_SITE_BYTES:
+                raise ValueError(f"Source is {declared // (1024 * 1024)}MB; the limit is "
+                                 f"{_MAX_SITE_BYTES // (1024 * 1024)}MB.")
+            chunks, total = [], 0
+            async for chunk in resp.aiter_bytes():
+                total += len(chunk)
+                if total > _MAX_SITE_BYTES:
+                    raise ValueError(f"Source exceeds {_MAX_SITE_BYTES // (1024 * 1024)}MB.")
+                chunks.append(chunk)
+            content_type = resp.headers.get("content-type", "").lower()
+            final_path = urlparse(str(resp.url)).path.lower()
+    data = b"".join(chunks)
+    if data[:4] == b"PK\x03\x04":
+        return ".zip", data
+    if "text/html" in content_type or final_path.endswith((".html", ".htm")):
+        return ".html", data
+    raise ValueError(
+        "The URL did not return a ZIP archive or an HTML document. Point source_url at a "
+        ".zip of the site (e.g. the build folder zipped) or a single .html file."
+    )
+
+
+async def _collect_from_url(source_url: str):
+    suffix, data = await _download_source(source_url)
+    with tempfile.NamedTemporaryFile(suffix=suffix, delete=False) as fh:
+        fh.write(data)
+        tmp = fh.name
+    try:
+        return _collect_site_files(tmp)
+    finally:
+        try:
+            os.unlink(tmp)
+        except OSError:
+            pass
+
+
+@mcp.tool()
+async def publish_website_from_url(
+    source_url: str,
+    title: str,
+    slug: str | None = None,
+) -> dict:
+    """Publish a site from a URL — a .zip of the site/build folder, or a single HTML page.
+
+    The hosted thin.host MCP endpoint cannot read your disk, so this is its publish
+    path: zip the build folder (`cd build && zip -r ../site.zip .`), put the zip
+    somewhere publicly reachable (a release asset, object storage, a slim.to link),
+    and pass that URL. Everything else — page/asset mapping, batching, Docusaurus
+    baseUrl detection and the `warning` it may produce — matches publish_website.
+    Private, loopback and cloud-metadata addresses are refused.
+
+    Args:
+        source_url: Public http(s) URL of a .zip archive or an .html file (≤150MB).
+        title: Human-readable site title.
+        slug: Optional URL slug (site lives at /s/<slug>/).
+
+    Returns:
+        Same shape as publish_website.
+    """
+    try:
+        pages, assets, skipped = await _collect_from_url(source_url)
+    except (ValueError, httpx.HTTPError) as e:
+        return _invalid_source(e, "publish_website_from_url")
+    return await _do_publish(pages, assets, skipped, title, slug)
+
+
+@mcp.tool()
+async def update_website_from_url(
+    website: str,
+    source_url: str,
+    title: str | None = None,
+    sync: bool = True,
+) -> dict:
+    """Redeploy an existing site from a URL (.zip of the site, or a single HTML page).
+
+    The URL form of update_website, for the hosted endpoint or any agent that has the
+    build as a downloadable archive. sync defaults to true here because a zipped build
+    is the whole site: after upload, files the archive does not contain are deleted
+    (dashboard-authored redirect pages are kept). Pass sync=false to upsert only.
+
+    Args:
+        website: The site's id, slug, or live URL.
+        source_url: Public http(s) URL of a .zip archive or an .html file (≤150MB).
+        title: Optional new site title.
+        sync: Treat the archive as the whole site (default true).
+
+    Returns:
+        Same shape as update_website.
+    """
+    try:
+        pages, assets, skipped = await _collect_from_url(source_url)
+    except (ValueError, httpx.HTTPError) as e:
+        return _invalid_source(e, "update_website_from_url")
+    return await _do_update(website, pages, assets, skipped, title, sync)
+
+
+@mcp.tool()
+async def list_websites(limit: int = 50) -> dict:
+    """List the account's hosted websites with their live URLs, newest first.
+
+    Args:
+        limit: Max sites to return (default 50, max 100).
+    """
+    async with _client() as client:
+        resp = await client.get(
+            f"{API_BASE_URL}/websites",
+            headers=_headers(),
+            params={"limit": limit},
+            timeout=30,
+        )
+
+    data = resp.json()
+    if resp.status_code >= 400:
+        return _format_error(data)
+
+    return {
+        "websites": [
+            {
+                "id": w["id"],
+                "slug": w["slug"],
+                "title": w["title"],
+                "url": w["url"],
+                "page_count": w["page_count"],
+                "asset_count": w["asset_count"],
+                "custom_domains": w["custom_domains"],
+                "updated_at": w["updated_at"],
+            }
+            for w in data.get("websites", [])
+        ],
+        "total": data.get("total", 0),
+    }
+
+
+def main():
+    """Console entry point (`thinhost-mcp`): serve the tools over stdio."""
+    mcp.run()
+
+
+if __name__ == "__main__":
+    main()

thinhost_mcp-1.1.0.dist-info/METADATA

@@ -0,0 +1,25 @@
+Metadata-Version: 2.1
+Name: thinhost-mcp
+Version: 1.1.0
+Summary: thin.host MCP server — publish sites, custom domains and transactional email for AI agents
+Home-page: https://thin.host
+Author: thin.host
+License: MIT
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: mcp>=1.9,<2
+Requires-Dist: httpx>=0.27.0
+
+# thinhost-mcp
+
+The thin.host MCP server as a console script. Run it with an API key from the
+thin.host dashboard (Settings → Create API key):
+
+    THIN_HOST_API_KEY=th_live_... THINHOST_API_URL=https://thin.host/v1 thinhost-mcp
+
+Claude Code:
+
+    claude mcp add thin-host -e THINHOST_API_URL=https://thin.host/v1 -e THIN_HOST_API_KEY=th_live_... -- uvx thinhost-mcp
+
+Prefer no install at all? The same tools are hosted at https://thin.host/mcp
+(bearer API key or OAuth). Docs: https://thin.host/docs/mcp

thinhost_mcp-1.1.0.dist-info/RECORD

@@ -0,0 +1,7 @@
+thinhost_mcp/__init__.py,sha256=LGVQyDsWifdACo7qztwb8RWWHds1E7uQ-ZqD8SAjyw4,22
+thinhost_mcp/server.py,sha256=WX7W1D7aI85t937r6zXoXKph65OlXBgNbPJRgiKtYPA,38701
+thinhost_mcp-1.1.0.dist-info/METADATA,sha256=VFmsMxgFcgwiJA2MM-kHx86TU8FLYIz9r3q9JmI-ejw,846
+thinhost_mcp-1.1.0.dist-info/WHEEL,sha256=F_8nXytLCRmZidw4XlphTE6Hrmgg2f_ecTHb1djbLtg,79
+thinhost_mcp-1.1.0.dist-info/entry_points.txt,sha256=754slrw7yC0E-LH6P-qoxbFCjNwnArgacgLbEFDmr04,58
+thinhost_mcp-1.1.0.dist-info/top_level.txt,sha256=wK2KhcCdz0e7oMP_VBro2MqLg9q_4l6LaALDh6MlKWA,13
+thinhost_mcp-1.1.0.dist-info/RECORD,,

thinhost_mcp-1.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: thinhost
+Root-Is-Purelib: true
+Tag: py3-none-any

thinhost_mcp-1.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+thinhost-mcp = thinhost_mcp.server:main

thinhost_mcp-1.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+thinhost_mcp