htmlhost-mcp 1.0.0

package/README.md

@@ -0,0 +1,167 @@
+# htmlhost MCP Server
+
+An [MCP (Model Context Protocol)](https://modelcontextprotocol.io) server that lets AI coding tools deploy and manage sites on [htmlhost.co](https://htmlhost.co).
+
+Works with **Cursor**, **Claude Desktop**, **Windsurf**, **Cline**, **Zed**, and any MCP-compatible tool.
+
+## Setup
+
+### 1. Install
+
+```bash
+npm install -g htmlhost-mcp
+```
+
+### 2. Authenticate
+
+The MCP server reuses the same token as the CLI. If you've already run `htmlhost login`, you're set.
+
+```bash
+npx htmlhost-cli login
+```
+
+### 3. Configure your AI tool
+
+#### Claude Desktop / Claude Code
+
+Add to your `claude_desktop_config.json`:
+
+```json
+{
+  "mcpServers": {
+    "htmlhost": {
+      "command": "htmlhost-mcp"
+    }
+  }
+}
+```
+
+#### Cursor
+
+Add to `.cursor/mcp.json` in your project:
+
+```json
+{
+  "mcpServers": {
+    "htmlhost": {
+      "command": "htmlhost-mcp"
+    }
+  }
+}
+```
+
+#### Windsurf
+
+Add to your MCP config:
+
+```json
+{
+  "mcpServers": {
+    "htmlhost": {
+      "command": "htmlhost-mcp"
+    }
+  }
+}
+```
+
+#### Any MCP-compatible tool
+
+The server speaks MCP over **stdio**. Run it as:
+
+```bash
+htmlhost-mcp
+```
+
+## Tools
+
+| Tool | Description |
+|---|---|
+| `deploy` | Deploy a local file or directory to htmlhost.co |
+| `deploy_html` | Deploy raw HTML content directly (no local files needed) |
+| `list_sites` | List all your sites |
+| `get_site` | Get details about a specific site (pages, assets, version) |
+| `pull_site` | Download a site's files to a local directory |
+| `delete_site` | Permanently delete a site |
+| `whoami` | Show the current authenticated user |
+
+### `deploy`
+
+Deploy a file or directory to htmlhost.co.
+
+```
+path      (required)  Absolute path to the file or directory
+slug      (optional)  Existing site slug to update
+title     (optional)  Title for the site
+ttl       (optional)  Time-to-live: 1d, 7d, 30d, or never
+```
+
+### `deploy_html`
+
+Deploy generated HTML directly — no files on disk needed. Perfect for when an AI assistant generates a webpage and wants to make it live immediately.
+
+```
+html      (required)  The HTML content to deploy
+slug      (optional)  Existing site slug to update
+title     (optional)  Title for the site
+ttl       (optional)  Time-to-live: 1d, 7d, 30d, or never
+```
+
+### `list_sites`
+
+Returns all sites, their URLs, sizes, TTLs, and plan usage.
+
+### `get_site`
+
+```
+slug      (required)  The site slug
+```
+
+Returns version, page routes, asset paths and sizes.
+
+### `pull_site`
+
+```
+slug      (required)  The site slug to pull
+directory (required)  Absolute path to write files into
+```
+
+Downloads all pages and assets into the specified directory.
+
+### `delete_site`
+
+```
+slug      (required)  The site slug to delete
+confirm   (required)  Must be true — safety check
+```
+
+### `whoami`
+
+Returns the authenticated user's email, name, handle, and plan.
+
+## Architecture
+
+```
+packages/mcp/
+├── bin/htmlhost-mcp.mjs   # Entry point (stdio transport)
+├── src/
+│   ├── server.mjs         # MCP tool definitions
+│   └── api.mjs            # API client (reuses ~/.htmlhostrc auth)
+├── package.json
+└── README.md
+```
+
+The MCP server reuses the same auth token (`~/.htmlhostrc`) and API endpoints as the [htmlhost CLI](https://www.npmjs.com/package/htmlhost-cli). No additional backend work is needed.
+
+## Development
+
+```bash
+cd packages/mcp
+npm install
+
+# Test locally — the server reads from stdin, writes to stdout
+echo '{"jsonrpc":"2.0","method":"initialize","params":{"capabilities":{}},"id":1}' | node bin/htmlhost-mcp.mjs
+```
+
+## License
+
+MIT

package/bin/htmlhost-mcp.mjs

@@ -0,0 +1,11 @@
+#!/usr/bin/env node
+/**
+ * htmlhost-mcp — MCP server entry point.
+ * Runs over stdio; designed for AI coding tools (Cursor, Claude, Windsurf, etc.)
+ */
+import { createServer } from "../src/server.mjs";
+import { StdioServerTransport } from "@modelcontextprotocol/server/stdio";
+
+const server = createServer();
+const transport = new StdioServerTransport();
+await server.connect(transport);

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "htmlhost-mcp",
+  "version": "1.0.0",
+  "description": "MCP server for htmlhost.co — deploy, list, and manage sites from AI coding tools",
+  "type": "module",
+  "bin": {
+    "htmlhost-mcp": "bin/htmlhost-mcp.mjs"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "files": [
+    "bin/",
+    "src/",
+    "README.md"
+  ],
+  "keywords": [
+    "mcp",
+    "htmlhost",
+    "deploy",
+    "hosting",
+    "model-context-protocol",
+    "ai",
+    "cursor",
+    "claude"
+  ],
+  "author": "htmlhost.co",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/htmlhost/mcp.git"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/server": "^2.1.0",
+    "zod": "^4.6.5"
+  }
+}

package/src/api.mjs

@@ -0,0 +1,258 @@
+/**
+ * API client for the htmlhost MCP server.
+ *
+ * Reuses the same ~/.htmlhostrc token and API base as the CLI,
+ * so `htmlhost login` is the only setup step needed.
+ */
+import { readFileSync, writeFileSync, statSync, readdirSync, mkdirSync } from "node:fs";
+import { join, basename, dirname, resolve } from "node:path";
+import { homedir } from "node:os";
+import { createHash } from "node:crypto";
+
+// ---------------------------------------------------------------------------
+// Config (mirrors packages/cli/src/config.mjs)
+// ---------------------------------------------------------------------------
+const CONFIG_PATH = join(homedir(), ".htmlhostrc");
+const DEFAULT_API = "https://htmlhost.co";
+
+function readConfig() {
+  try {
+    return JSON.parse(readFileSync(CONFIG_PATH, "utf8"));
+  } catch {
+    return {};
+  }
+}
+
+export function getToken() {
+  return readConfig().token || null;
+}
+
+export function getApi() {
+  return readConfig().api || DEFAULT_API;
+}
+
+export function isLoggedIn() {
+  return !!getToken();
+}
+
+// ---------------------------------------------------------------------------
+// HTTP helpers (mirrors packages/cli/src/api.mjs — minus terminal UI)
+// ---------------------------------------------------------------------------
+class ApiError extends Error {
+  constructor(message, status) {
+    super(message);
+    this.status = status;
+  }
+}
+
+function headers(extra = {}) {
+  const token = getToken();
+  if (!token) throw new ApiError("Not logged in. Run `htmlhost login` in a terminal first.", 0);
+  return { Authorization: `Bearer ${token}`, ...extra };
+}
+
+async function withRetry(fn, label = "request", retries = 3) {
+  let lastError;
+  for (let attempt = 1; attempt <= retries; attempt++) {
+    try {
+      return await fn();
+    } catch (e) {
+      lastError = e;
+      const isRetryable = !(e instanceof ApiError) || (e.status >= 500 && e.status < 600);
+      if (!isRetryable || attempt === retries) throw e;
+      await new Promise((r) => setTimeout(r, 500 * Math.pow(2, attempt - 1)));
+    }
+  }
+  throw lastError;
+}
+
+export async function apiGet(path) {
+  return withRetry(async () => {
+    const res = await fetch(`${getApi()}${path}`, { headers: headers() });
+    const data = await res.json();
+    if (!res.ok) throw new ApiError(data.error || `HTTP ${res.status}`, res.status);
+    return data;
+  }, `GET ${path}`);
+}
+
+export async function apiPost(path, body) {
+  return withRetry(async () => {
+    const res = await fetch(`${getApi()}${path}`, {
+      method: "POST",
+      headers: headers({ "Content-Type": "application/json" }),
+      body: JSON.stringify(body),
+    });
+    const data = await res.json();
+    if (!res.ok) throw new ApiError(data.error || `HTTP ${res.status}`, res.status);
+    return data;
+  }, `POST ${path}`);
+}
+
+export async function apiDelete(path) {
+  return withRetry(async () => {
+    const res = await fetch(`${getApi()}${path}`, {
+      method: "DELETE",
+      headers: headers(),
+    });
+    const data = await res.json();
+    if (!res.ok) throw new ApiError(data.error || `HTTP ${res.status}`, res.status);
+    return data;
+  }, `DELETE ${path}`);
+}
+
+export async function downloadBuffer(url) {
+  const res = await fetch(url);
+  if (!res.ok) throw new ApiError(`Download failed: HTTP ${res.status}`, res.status);
+  return Buffer.from(await res.arrayBuffer());
+}
+
+// ---------------------------------------------------------------------------
+// MIME detection (mirrors packages/cli/src/ui.mjs)
+// ---------------------------------------------------------------------------
+const MIME_MAP = {
+  png: "image/png", jpg: "image/jpeg", jpeg: "image/jpeg", gif: "image/gif",
+  svg: "image/svg+xml", webp: "image/webp", avif: "image/avif", ico: "image/x-icon",
+  woff: "font/woff", woff2: "font/woff2", ttf: "font/ttf", otf: "font/otf",
+  css: "text/css", js: "text/javascript", mjs: "text/javascript",
+  json: "application/json", mp4: "video/mp4", webm: "video/webm",
+  mp3: "audio/mpeg", ogg: "audio/ogg", wav: "audio/wav", pdf: "application/pdf",
+};
+
+export function mimeFromExt(filename) {
+  const ext = filename.split(".").pop()?.toLowerCase();
+  return MIME_MAP[ext] || "application/octet-stream";
+}
+
+// ---------------------------------------------------------------------------
+// File discovery (mirrors packages/cli/src/commands/deploy.mjs)
+// ---------------------------------------------------------------------------
+const DEFAULT_IGNORE = [
+  "node_modules", ".git", ".DS_Store", ".htmlhost", ".env", ".env.local",
+  ".env.production", ".env.development", ".vscode", ".idea", "Thumbs.db",
+  ".gitignore", ".npmrc", "package-lock.json", "yarn.lock", "pnpm-lock.yaml",
+  "AGENTS.md", "CLAUDE.md", "GEMINI.md", ".claude", ".cursor", ".cursorrules",
+  ".windsurfrules", ".github",
+];
+
+function shouldIgnore(name) {
+  if (name.startsWith(".") && DEFAULT_IGNORE.includes(name)) return true;
+  return DEFAULT_IGNORE.includes(name);
+}
+
+export function findAllFiles(baseDir, currentDir) {
+  const entries = readdirSync(currentDir, { withFileTypes: true });
+  const results = [];
+  for (const entry of entries) {
+    if (shouldIgnore(entry.name)) continue;
+    const fullPath = join(currentDir, entry.name);
+    if (entry.isDirectory()) {
+      results.push(...findAllFiles(baseDir, fullPath));
+    } else if (entry.isFile()) {
+      let size;
+      try { size = statSync(fullPath).size; } catch { continue; }
+      results.push({ filePath: fullPath, relativePath: fullPath.slice(baseDir.length + 1), size });
+    }
+  }
+  return results;
+}
+
+export function pagePathForFile(relativePath) {
+  if (relativePath === "index.html") return "/";
+  if (basename(relativePath) === "index.html") return `/${dirname(relativePath)}`;
+  return "/" + relativePath.replace(/\.html$/, "");
+}
+
+// ---------------------------------------------------------------------------
+// Deploy helpers
+// ---------------------------------------------------------------------------
+
+/**
+ * Deploy a directory to htmlhost. Non-interactive version of CLI deploy.
+ * Returns { slug, url, version, pageCount }.
+ */
+export async function deployDirectory(dirPath, { slug = null, title = null, ttl = null } = {}) {
+  const resolvedDir = resolve(dirPath);
+  const allFiles = findAllFiles(resolvedDir, resolvedDir);
+
+  if (allFiles.length === 0) throw new Error("No files found in directory.");
+
+  const hasIndex = allFiles.some((f) => f.relativePath === "index.html");
+  if (!hasIndex) {
+    const htmlFiles = allFiles.filter((f) => f.relativePath.endsWith(".html"));
+    if (htmlFiles.length === 0) throw new Error("No index.html or HTML files found.");
+  }
+
+  const htmlFiles = allFiles.filter((f) => f.relativePath.endsWith(".html"));
+  const assetFiles = allFiles.filter((f) => !f.relativePath.endsWith(".html"));
+
+  // Build page payloads
+  const pagePayloads = [];
+  const seenPaths = new Set();
+  for (const file of htmlFiles) {
+    const html = readFileSync(file.filePath, "utf8");
+    const pagePath = pagePathForFile(file.relativePath);
+    if (seenPaths.has(pagePath)) continue;
+    seenPaths.add(pagePath);
+    pagePayloads.push({ path: pagePath, html });
+  }
+
+  // Upload assets via presigned URLs
+  const assetPayloads = [];
+  if (assetFiles.length > 0) {
+    const uploadUrlReqBody = {
+      slug: slug || undefined,
+      isNewSite: !slug,
+      html: pagePayloads[0]?.html || "",
+      assets: assetFiles.map((f) => {
+        const buffer = readFileSync(f.filePath);
+        const hash = createHash("sha256").update(buffer).digest("hex");
+        f.buffer = buffer;
+        return { path: f.relativePath, sizeBytes: f.size, mimeType: mimeFromExt(basename(f.filePath)), hash };
+      }),
+    };
+
+    const urlData = await apiPost("/api/sites/upload-url", uploadUrlReqBody);
+    const { slug: generatedSlug, uploadUrls } = urlData;
+    if (generatedSlug && !slug) slug = generatedSlug;
+
+    for (const u of uploadUrls) {
+      const file = assetFiles.find((f) => f.relativePath === u.path);
+      if (u.uploadUrl) {
+        const res = await fetch(u.uploadUrl, {
+          method: "PUT",
+          headers: { "Content-Type": u.mimeType },
+          body: file.buffer,
+        });
+        if (!res.ok) throw new Error(`Asset upload failed for ${u.path}: HTTP ${res.status}`);
+      }
+      assetPayloads.push({
+        path: u.path, mimeType: u.mimeType, sizeBytes: u.sizeBytes,
+        storageKey: u.storageKey, hash: u.hash,
+      });
+    }
+  }
+
+  // Final deploy
+  const body = { pages: pagePayloads, assets: assetPayloads };
+  if (ttl) body.ttl = ttl;
+  if (slug) body.slug = slug;
+  if (title) body.title = title;
+  if (!slug) body.isNewSite = true;
+
+  return await apiPost("/api/sites", body);
+}
+
+/**
+ * Deploy a single HTML file. Non-interactive version of CLI deploy.
+ */
+export async function deploySingleFile(filePath, { slug = null, title = null, ttl = null } = {}) {
+  const resolvedPath = resolve(filePath);
+  const html = readFileSync(resolvedPath, "utf8");
+
+  const body = { html };
+  if (ttl) body.ttl = ttl;
+  if (slug) body.slug = slug;
+  if (title) body.title = title;
+
+  return await apiPost("/api/sites", body);
+}

package/src/server.mjs

@@ -0,0 +1,318 @@
+/**
+ * htmlhost MCP server — tool definitions.
+ *
+ * Exposes htmlhost operations as MCP tools so AI coding assistants
+ * (Cursor, Claude, Windsurf, Cline, Zed, etc.) can deploy and manage
+ * sites on behalf of the user.
+ *
+ * Auth: reuses the CLI token stored in ~/.htmlhostrc.
+ *       Run `htmlhost login` once in a terminal to authenticate.
+ */
+import { McpServer } from "@modelcontextprotocol/server";
+import { z } from "zod";
+import { existsSync, statSync, readFileSync, writeFileSync, mkdirSync } from "node:fs";
+import { resolve, dirname, join, basename } from "node:path";
+import {
+  isLoggedIn,
+  getApi,
+  apiGet,
+  apiPost,
+  apiDelete,
+  downloadBuffer,
+  deployDirectory,
+  deploySingleFile,
+  findAllFiles,
+  pagePathForFile,
+  mimeFromExt,
+} from "./api.mjs";
+
+const VERSION = "1.0.0";
+
+/**
+ * Helper: wraps a handler to return proper MCP content and catch errors.
+ */
+function wrap(fn) {
+  return async (args) => {
+    try {
+      const result = await fn(args);
+      const text = typeof result === "string" ? result : JSON.stringify(result, null, 2);
+      return { content: [{ type: "text", text }] };
+    } catch (e) {
+      return { content: [{ type: "text", text: `Error: ${e.message}` }], isError: true };
+    }
+  };
+}
+
+export function createServer() {
+  const server = new McpServer({
+    name: "htmlhost",
+    version: VERSION,
+  });
+
+  // -------------------------------------------------------------------
+  // Tool: deploy
+  // -------------------------------------------------------------------
+  server.registerTool(
+    "deploy",
+    {
+      title: "Deploy to htmlhost",
+      description:
+        "Deploy a file or directory to htmlhost.co. " +
+        "Pass an absolute path to a directory (deploys all files) or a single HTML file. " +
+        "Optionally set slug (to update an existing site), title, and ttl.",
+      inputSchema: z.object({
+        path: z.string().describe("Absolute path to the file or directory to deploy"),
+        slug: z.string().optional().describe("Existing site slug to update (omit to create a new site)"),
+        title: z.string().optional().describe("Title for the site"),
+        ttl: z.string().optional().describe("Time-to-live: 1d, 7d, 30d, or never"),
+      }),
+    },
+    wrap(async ({ path, slug, title, ttl }) => {
+      if (!isLoggedIn()) return "Not logged in. Run `htmlhost login` in a terminal first.";
+
+      const resolvedPath = resolve(path);
+      if (!existsSync(resolvedPath)) return `Path not found: ${path}`;
+
+      const stat = statSync(resolvedPath);
+      const opts = { slug, title, ttl };
+
+      let data;
+      if (stat.isDirectory()) {
+        data = await deployDirectory(resolvedPath, opts);
+      } else {
+        data = await deploySingleFile(resolvedPath, opts);
+      }
+
+      const pc = data.pageCount || 1;
+      return {
+        message: "Deployed successfully",
+        url: `https://${data.url}`,
+        slug: data.slug,
+        version: data.version,
+        pages: pc,
+        ttl: data.ttl,
+        expiresAt: data.expiresAt || null,
+      };
+    })
+  );
+
+  // -------------------------------------------------------------------
+  // Tool: list_sites
+  // -------------------------------------------------------------------
+  server.registerTool(
+    "list_sites",
+    {
+      title: "List sites",
+      description:
+        "List all sites owned by the authenticated user on htmlhost.co. " +
+        "Returns slug, URL, title, size, TTL, and expiration for each site.",
+      inputSchema: z.object({}),
+    },
+    wrap(async () => {
+      if (!isLoggedIn()) return "Not logged in. Run `htmlhost login` in a terminal first.";
+
+      const data = await apiGet("/api/sites");
+      const sites = (data.sites || []).map((s) => ({
+        slug: s.slug,
+        url: `https://${s.slug}.htmlhost.co`,
+        title: s.title || null,
+        size: s.size,
+        ttl: s.ttl,
+        isMultiPage: s.isMultiPage,
+        expiresAt: s.expiresAt || null,
+      }));
+
+      return {
+        count: sites.length,
+        usage: data.usage,
+        sites,
+      };
+    })
+  );
+
+  // -------------------------------------------------------------------
+  // Tool: get_site
+  // -------------------------------------------------------------------
+  server.registerTool(
+    "get_site",
+    {
+      title: "Get site details",
+      description:
+        "Get detailed information about a specific site including its pages and assets.",
+      inputSchema: z.object({
+        slug: z.string().describe("The site slug (e.g. 'my-site')"),
+      }),
+    },
+    wrap(async ({ slug }) => {
+      if (!isLoggedIn()) return "Not logged in. Run `htmlhost login` in a terminal first.";
+
+      const cleanSlug = slug.replace(/\.htmlhost\.co$/, "");
+      const data = await apiGet(`/api/sites/pull?slug=${encodeURIComponent(cleanSlug)}&meta=true`);
+
+      return {
+        slug: cleanSlug,
+        url: `https://${cleanSlug}.htmlhost.co`,
+        version: data.version,
+        updatedAt: data.updatedAt,
+        pages: (data.pages || []).map((p) => ({
+          path: p.path,
+          sizeBytes: p.sizeBytes || (p.html ? Buffer.byteLength(p.html) : 0),
+        })),
+        assets: (data.assets || []).map((a) => ({
+          path: a.path,
+          mimeType: a.mimeType,
+          sizeBytes: a.sizeBytes,
+        })),
+      };
+    })
+  );
+
+  // -------------------------------------------------------------------
+  // Tool: pull_site
+  // -------------------------------------------------------------------
+  server.registerTool(
+    "pull_site",
+    {
+      title: "Pull site to local directory",
+      description:
+        "Download all pages and assets from a deployed htmlhost site into a local directory. " +
+        "Creates the directory if it doesn't exist.",
+      inputSchema: z.object({
+        slug: z.string().describe("The site slug to pull"),
+        directory: z.string().describe("Absolute path to the local directory to write files into"),
+      }),
+    },
+    wrap(async ({ slug, directory }) => {
+      if (!isLoggedIn()) return "Not logged in. Run `htmlhost login` in a terminal first.";
+
+      const cleanSlug = slug.replace(/\.htmlhost\.co$/, "");
+      const destDir = resolve(directory);
+      mkdirSync(destDir, { recursive: true });
+
+      const data = await apiGet(`/api/sites/pull?slug=${encodeURIComponent(cleanSlug)}`);
+      const written = [];
+
+      // Write pages
+      for (const page of data.pages || []) {
+        const localFile = page.path === "/"
+          ? "index.html"
+          : `${page.path.replace(/^\//, "")}.html`;
+        const localPath = join(destDir, localFile);
+        mkdirSync(dirname(localPath), { recursive: true });
+        writeFileSync(localPath, page.html, "utf8");
+        written.push(localFile);
+      }
+
+      // Write assets
+      for (const asset of data.assets || []) {
+        const localPath = join(destDir, asset.path);
+        mkdirSync(dirname(localPath), { recursive: true });
+
+        if (asset.content !== null && asset.content !== undefined) {
+          writeFileSync(localPath, asset.content, "utf8");
+        } else if (asset.downloadUrl) {
+          const buf = await downloadBuffer(asset.downloadUrl);
+          writeFileSync(localPath, buf);
+        } else {
+          continue;
+        }
+        written.push(asset.path);
+      }
+
+      return {
+        message: `Pulled ${written.length} files from ${cleanSlug}.htmlhost.co`,
+        directory: destDir,
+        version: data.version,
+        files: written,
+      };
+    })
+  );
+
+  // -------------------------------------------------------------------
+  // Tool: delete_site
+  // -------------------------------------------------------------------
+  server.registerTool(
+    "delete_site",
+    {
+      title: "Delete site",
+      description:
+        "Permanently delete a site from htmlhost.co. This cannot be undone.",
+      inputSchema: z.object({
+        slug: z.string().describe("The site slug to delete"),
+        confirm: z.boolean().describe("Must be true to confirm deletion"),
+      }),
+    },
+    wrap(async ({ slug, confirm }) => {
+      if (!isLoggedIn()) return "Not logged in. Run `htmlhost login` in a terminal first.";
+      if (!confirm) return "Deletion not confirmed. Set confirm to true to proceed.";
+
+      const cleanSlug = slug.replace(/\.htmlhost\.co$/, "");
+      await apiDelete(`/api/sites?slug=${encodeURIComponent(cleanSlug)}`);
+
+      return { message: `Deleted ${cleanSlug}.htmlhost.co` };
+    })
+  );
+
+  // -------------------------------------------------------------------
+  // Tool: whoami
+  // -------------------------------------------------------------------
+  server.registerTool(
+    "whoami",
+    {
+      title: "Who am I",
+      description: "Show the currently authenticated htmlhost user and plan details.",
+      inputSchema: z.object({}),
+    },
+    wrap(async () => {
+      if (!isLoggedIn()) return "Not logged in. Run `htmlhost login` in a terminal first.";
+
+      const data = await apiGet("/api/tokens/me");
+      return {
+        email: data.email,
+        name: data.name || null,
+        handle: data.handle || null,
+        plan: data.plan,
+      };
+    })
+  );
+
+  // -------------------------------------------------------------------
+  // Tool: deploy_html
+  // -------------------------------------------------------------------
+  server.registerTool(
+    "deploy_html",
+    {
+      title: "Deploy HTML content",
+      description:
+        "Deploy raw HTML content directly (no local files needed). " +
+        "Useful when an AI generates HTML and wants to deploy it immediately.",
+      inputSchema: z.object({
+        html: z.string().describe("The HTML content to deploy"),
+        slug: z.string().optional().describe("Existing site slug to update (omit to create new)"),
+        title: z.string().optional().describe("Title for the site"),
+        ttl: z.string().optional().describe("Time-to-live: 1d, 7d, 30d, or never"),
+      }),
+    },
+    wrap(async ({ html, slug, title, ttl }) => {
+      if (!isLoggedIn()) return "Not logged in. Run `htmlhost login` in a terminal first.";
+
+      const body = { html };
+      if (slug) body.slug = slug;
+      if (title) body.title = title;
+      if (ttl) body.ttl = ttl;
+
+      const data = await apiPost("/api/sites", body);
+
+      return {
+        message: "Deployed successfully",
+        url: `https://${data.url}`,
+        slug: data.slug,
+        version: data.version,
+        ttl: data.ttl,
+        expiresAt: data.expiresAt || null,
+      };
+    })
+  );
+
+  return server;
+}