htmlhost-mcp 1.2.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.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "htmlhost-mcp",
-  "version": "1.2.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

@@ -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) {

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.2.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,

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.`;
+}