htmlhost-mcp 1.1.0 → 1.3.0

package/README.md

@@ -12,6 +12,14 @@ Works with **Cursor**, **Claude Desktop**, **Windsurf**, **Cline**, **Zed**, and
 npm install -g htmlhost-mcp
 ```
 
+Or skip installing and use `npx -y htmlhost-mcp@latest` as the command, which fetches the newest version each
+time your AI tool starts the server.
+
+**Updates:** the server checks npm once a day. A global install updates itself in the background (restart your
+AI tool to load it), and the first tool result of a session tells your AI tool when a newer version exists. With
+npx, keep `@latest` in the command: a bare `npx -y htmlhost-mcp` keeps reusing its cached copy. Set
+`HTMLHOST_NO_UPDATE_CHECK=1` to turn the check off.
+
 ### 2. Authenticate
 
 The MCP server reuses the same token as the CLI. If you've already run `htmlhost login`, you're set.
@@ -97,6 +105,11 @@ title     (optional)  Title for the site
 ttl       (optional)  Time-to-live: 1d, 7d, 30d, or never
 ```
 
+A `_redirects` file at the root of a deployed directory sets the site's redirects,
+one per line: `/old-page /new-page`, optionally followed by `301` (default) or `302`.
+It isn't published. Each deploy with the file replaces the redirects it set before;
+redirects added in the dashboard stay. `pull_site` writes the file back.
+
 ### `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.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "htmlhost-mcp",
-  "version": "1.1.0",
+  "version": "1.3.0",
   "description": "MCP server for htmlhost.co — deploy, list, and manage sites from AI coding tools",
   "type": "module",
   "bin": {

package/src/api.mjs

@@ -4,7 +4,7 @@
  * 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 { readFileSync, writeFileSync, statSync, readdirSync, mkdirSync, existsSync } from "node:fs";
 import { join, basename, dirname, resolve } from "node:path";
 import { homedir } from "node:os";
 import { createHash } from "node:crypto";
@@ -13,9 +13,11 @@ import { createHash } from "node:crypto";
 // Config (mirrors packages/cli/src/config.mjs)
 // ---------------------------------------------------------------------------
 const CONFIG_PATH = join(homedir(), ".htmlhostrc");
+/** Sent with every request, so the API can tell which version is calling. Kept in step with server.mjs. */
+export const CLIENT_VERSION = "1.3.0";
 const DEFAULT_API = "https://htmlhost.co";
 
-function readConfig() {
+export function readConfig() {
   try {
     return JSON.parse(readFileSync(CONFIG_PATH, "utf8"));
   } catch {
@@ -23,6 +25,13 @@ function readConfig() {
   }
 }
 
+/** Merge keys into ~/.htmlhostrc (shared with the CLI), keeping it readable by its owner only. */
+export function writeConfig(data) {
+  try {
+    writeFileSync(CONFIG_PATH, JSON.stringify({ ...readConfig(), ...data }, null, 2) + "\n", { encoding: "utf8", mode: 0o600 });
+  } catch { /* a read-only home: the check just runs again next time */ }
+}
+
 export function getToken() {
   return readConfig().token || null;
 }
@@ -48,7 +57,7 @@ class ApiError extends Error {
 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}`, "X-HTMLHost-Client": "mcp", ...extra };
+  return { Authorization: `Bearer ${token}`, "X-HTMLHost-Client": "mcp", "X-HTMLHost-Client-Version": CLIENT_VERSION, ...extra };
 }
 
 async function withRetry(fn, label = "request", retries = 3) {
@@ -132,6 +141,8 @@ const DEFAULT_IGNORE = [
   ".gitignore", ".npmrc", "package-lock.json", "yarn.lock", "pnpm-lock.yaml",
   "AGENTS.md", "CLAUDE.md", "GEMINI.md", ".claude", ".cursor", ".cursorrules",
   ".windsurfrules", ".github",
+  // Redirect rules: sent with the deploy and applied by htmlhost, never published as a file.
+  "_redirects",
 ];
 
 function shouldIgnore(name) {
@@ -184,6 +195,8 @@ export async function deployDirectory(dirPath, { slug = null, title = null, ttl
 
   const htmlFiles = allFiles.filter((f) => f.relativePath.endsWith(".html"));
   const assetFiles = allFiles.filter((f) => !f.relativePath.endsWith(".html"));
+  // Decided before upload-url may hand back a generated slug for the new site.
+  const isNewSite = !slug;
 
   // Build page payloads
   const pagePayloads = [];
@@ -232,12 +245,15 @@ export async function deployDirectory(dirPath, { slug = null, title = null, ttl
     }
   }
 
-  // Final deploy
+  // Final deploy. A root `_redirects` file (Netlify style) replaces the site's
+  // redirects from this file; rules added in the dashboard stay. No file, no change.
   const body = { pages: pagePayloads, assets: assetPayloads };
+  const redirectsPath = join(resolvedDir, "_redirects");
+  if (existsSync(redirectsPath)) body.redirects = readFileSync(redirectsPath, "utf8");
   if (ttl) body.ttl = ttl;
   if (slug) body.slug = slug;
   if (title) body.title = title;
-  if (!slug) body.isNewSite = true;
+  if (isNewSite) body.isNewSite = true;
 
   return await apiPost("/api/sites", body);
 }

package/src/server.mjs

@@ -24,18 +24,28 @@ import {
   findAllFiles,
   pagePathForFile,
   mimeFromExt,
+  CLIENT_VERSION,
 } from "./api.mjs";
+import { checkForUpdate } from "./update.mjs";
 
-const VERSION = "1.1.0";
+const VERSION = CLIENT_VERSION;
 
 /**
  * Helper: wraps a handler to return proper MCP content and catch errors.
  */
+/** An update notice (update.mjs), shown once: with the first tool result after the check finishes. */
+let updateNotice = null;
+let updateNoticeShown = false;
+
 function wrap(fn) {
   return async (args) => {
     try {
       const result = await fn(args);
-      const text = typeof result === "string" ? result : JSON.stringify(result, null, 2);
+      let text = typeof result === "string" ? result : JSON.stringify(result, null, 2);
+      if (updateNotice && !updateNoticeShown) {
+        updateNoticeShown = true;
+        text += `\n\nNote for the user: ${updateNotice}`;
+      }
       return { content: [{ type: "text", text }] };
     } catch (e) {
       return { content: [{ type: "text", text: `Error: ${e.message}` }], isError: true };
@@ -44,6 +54,8 @@ function wrap(fn) {
 }
 
 export function createServer() {
+  // In the background: never delays starting up or a tool call.
+  void checkForUpdate(VERSION).then((notice) => { updateNotice = notice; }).catch(() => {});
   const server = new McpServer({
     name: "htmlhost",
     version: VERSION,
@@ -59,7 +71,8 @@ export function createServer() {
       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.",
+        "Optionally set slug (to update an existing site), title, and ttl. " +
+        "A `_redirects` file at the directory's root (one `/old /new [301|302]` per line) sets the site's redirects and isn't published.",
       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)"),
@@ -92,6 +105,7 @@ export function createServer() {
         pages: pc,
         ttl: data.ttl,
         expiresAt: data.expiresAt || null,
+        ...(data.redirects ? { redirects: data.redirects } : {}),
       };
     })
   );
@@ -219,6 +233,12 @@ export function createServer() {
         written.push(asset.path);
       }
 
+      // Redirects that came from a deployed _redirects file
+      if (data.redirectsFile) {
+        writeFileSync(join(destDir, "_redirects"), data.redirectsFile, "utf8");
+        written.push("_redirects");
+      }
+
       return {
         message: `Pulled ${written.length} files from ${cleanSlug}.htmlhost.co`,
         directory: destDir,

package/src/update.mjs

@@ -0,0 +1,118 @@
+/**
+ * Keeping htmlhost-mcp current, like the CLI's update check.
+ *
+ * An MCP server is a child process of the AI tool, talking over stdio, so it
+ * can't swap itself out while running and must never print to stdout. On
+ * start it checks the npm registry (at most once a day, cached in the shared
+ * ~/.htmlhostrc). When a newer version exists:
+ *
+ * - installed globally (`htmlhost-mcp` command): it installs the new version
+ *   in the background, so the next start of the AI tool uses it;
+ * - run with `npx -y htmlhost-mcp@latest`: npx fetches it on the next start;
+ * - run with a bare `npx -y htmlhost-mcp`: npx keeps reusing its cached copy,
+ *   so the notice asks for `@latest` in the MCP config.
+ *
+ * The first tool result of the session carries a one-line notice, so the AI
+ * tells the user. Set HTMLHOST_NO_UPDATE_CHECK to turn all of this off.
+ */
+import { spawn } from "node:child_process";
+import { realpathSync } from "node:fs";
+import { sep } from "node:path";
+import { readConfig, writeConfig } from "./api.mjs";
+
+const PACKAGE_NAME = "htmlhost-mcp";
+const CHECK_INTERVAL_MS = 24 * 60 * 60 * 1000;
+
+/** True when a is a newer x.y.z than b. */
+export function isNewer(a, b) {
+  const pa = String(a).split(".").map(Number);
+  const pb = String(b).split(".").map(Number);
+  for (let i = 0; i < 3; i++) {
+    if ((pa[i] || 0) > (pb[i] || 0)) return true;
+    if ((pa[i] || 0) < (pb[i] || 0)) return false;
+  }
+  return false;
+}
+
+/** How this server was started: "npx" (from npx's cache), "global", or "local" (a project's node_modules, or a checkout). */
+export function installKind(entry = process.argv[1] || "", globalRoot = null) {
+  let real = entry;
+  try { real = realpathSync(entry); } catch { /* keep the path as given */ }
+  if (real.includes(`${sep}_npx${sep}`)) return "npx";
+  if (globalRoot && real.startsWith(globalRoot + sep)) return "global";
+  return "local";
+}
+
+/** `npm root -g`, or null. */
+function npmGlobalRoot() {
+  return new Promise((resolve) => {
+    try {
+      const child = spawn(process.platform === "win32" ? "npm.cmd" : "npm", ["root", "-g"], { stdio: ["ignore", "pipe", "ignore"] });
+      let out = "";
+      child.stdout.on("data", (d) => (out += d));
+      child.on("error", () => resolve(null));
+      child.on("close", () => resolve(out.trim() || null));
+      setTimeout(() => { child.kill(); resolve(null); }, 5000).unref();
+    } catch {
+      resolve(null);
+    }
+  });
+}
+
+/** The newest published version, from the cache when it's less than a day old. */
+async function latestVersion() {
+  const config = readConfig();
+  if (config.mcpLatestVersion && Date.now() - (config.mcpLastUpdateCheck || 0) < CHECK_INTERVAL_MS) {
+    return config.mcpLatestVersion;
+  }
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), 5000);
+  try {
+    const res = await fetch(`https://registry.npmjs.org/${PACKAGE_NAME}/latest`, { signal: controller.signal, headers: { Accept: "application/json" } });
+    if (!res.ok) return null;
+    const data = await res.json();
+    if (!data?.version) return null;
+    writeConfig({ mcpLastUpdateCheck: Date.now(), mcpLatestVersion: data.version });
+    return data.version;
+  } catch {
+    return null;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+/** Install the latest version globally, detached and silent (stdout belongs to MCP). */
+function installInBackground() {
+  try {
+    const child = spawn(process.platform === "win32" ? "npm.cmd" : "npm", ["install", "-g", `${PACKAGE_NAME}@latest`], {
+      stdio: "ignore",
+      detached: true,
+    });
+    child.on("error", () => {});
+    child.unref();
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Check for a newer version and act on it. Resolves to a one-line notice for
+ * the AI to pass on, or null. Never throws, never writes to stdout.
+ */
+export async function checkForUpdate(currentVersion) {
+  if (process.env.HTMLHOST_NO_UPDATE_CHECK || process.env.CI) return null;
+  const latest = await latestVersion();
+  if (!latest || !isNewer(latest, currentVersion)) return null;
+  const kind = installKind(process.argv[1], await npmGlobalRoot());
+  const head = `htmlhost-mcp ${latest} is available (this is ${currentVersion}).`;
+  if (kind === "global") {
+    return installInBackground()
+      ? `${head} It's being installed now; restart your AI tool (or its MCP servers) to use it.`
+      : `${head} Update with: npm install -g ${PACKAGE_NAME}@latest, then restart your AI tool.`;
+  }
+  if (kind === "npx") {
+    return `${head} Restart your AI tool to load it. If it still reports ${currentVersion}, change the MCP config to run "npx -y ${PACKAGE_NAME}@latest" so npx always fetches the newest version.`;
+  }
+  return `${head} Update the htmlhost-mcp package this server runs from, then restart your AI tool.`;
+}