htmlhost-cli 2.8.0 → 2.10.0

package/README.md

@@ -1,7 +1,11 @@
 # htmlhost
 
+[![npm](https://img.shields.io/npm/v/htmlhost-cli)](https://www.npmjs.com/package/htmlhost-cli) [![MCP compatible](https://img.shields.io/badge/MCP-compatible-8A2BE2)](https://htmlhost.co/docs/mcp)
+
 Deploy HTML projects from the terminal. [htmlhost.co](https://htmlhost.co)
 
+Want your AI assistant to deploy for you? The [htmlhost MCP server](https://www.npmjs.com/package/htmlhost-mcp) uses the same login as this CLI and works with Claude, Cursor, VS Code, Windsurf and Codex. [Setup guide →](https://htmlhost.co/docs/mcp)
+
 ## Install
 
 ```bash
@@ -68,6 +72,22 @@ blog/post-1.html → /blog/post-1
 
 Add a `404.html` file and it will be served automatically for missing pages.
 
+**Redirects:** A `_redirects` file at the folder's root sets the site's
+redirects, one per line in the Netlify style:
+
+```
+# old address        new address         (optional) 301 or 302
+/about-us            /about
+/blog/*              /news/*
+/sale                /offers             302
+/shop                https://shop.example.com
+```
+
+The file is sent with the deploy and isn't published. Each deploy with the file
+replaces the redirects it set before; redirects added in the dashboard stay (and
+win when both cover the same path). Without the file, a deploy leaves redirects
+as they are. `htmlhost pull` and `htmlhost clone` write the file back.
+
 **Single-file deploy:** When you pass a specific file (`htmlhost deploy page.html`),
 only that file is deployed. Local CSS, JS, and images referenced in the HTML are
 automatically inlined or uploaded and rewritten to hosted URLs.
@@ -162,6 +182,18 @@ Open a deployed site in the default browser.
 ### `htmlhost delete <slug>`
 Delete a site. Use `--force` to skip confirmation.
 
+### `htmlhost versions [slug]`
+List a site's published versions, newest first: when, who, how it was published, and what changed. Every deploy and every save in the web editor is a version. Without a slug, uses the linked site. Add `--json` for machine-readable output.
+
+### `htmlhost rollback [slug] [version]`
+Make an earlier version live again. Without a version number, goes back to the version before the live one. The old version is published again as a new version, so you can switch back the same way. Needs the site owner to be on Pro. Use `--force` to skip confirmation, then `htmlhost pull` so your local files match.
+
+```bash
+htmlhost versions            # linked site
+htmlhost rollback            # back one version
+htmlhost rollback my-site 12 # make v12 live again
+```
+
 ### `htmlhost whoami`
 Show current authenticated user and plan.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "htmlhost-cli",
-  "version": "2.8.0",
+  "version": "2.10.0",
   "description": "Deploy HTML files from the terminal — htmlhost.co CLI",
   "type": "module",
   "bin": {

package/src/api.mjs

@@ -49,6 +49,7 @@ function headers(extra = {}) {
   if (!token) throw new ApiError("Not logged in. Run: htmlhost login", 0);
   return {
     Authorization: `Bearer ${token}`,
+    "X-HTMLHost-Client": "cli",
     ...extra,
   };
 }

package/src/cli.mjs

@@ -5,7 +5,7 @@ import { bold, dim, cyan, err } from "./ui.mjs";
 import { ApiError } from "./api.mjs";
 import { startUpdateCheck, applyUpdate } from "./update.mjs";
 
-const VERSION = "2.8.0";
+const VERSION = "2.10.0";
 
 const HELP = `
   ${bold("htmlhost")} ${dim(`v${VERSION}`)} — deploy HTML from the terminal
@@ -19,6 +19,8 @@ const HELP = `
     ${cyan("htmlhost agents")} [dir]             Teach your AI coding tool htmlhost (AGENTS.md)
     ${cyan("htmlhost recipients")} [slug] [cmd]  Manage form notification recipients
     ${cyan("htmlhost list")}                     List your sites
+    ${cyan("htmlhost versions")} [slug]         List a site's published versions
+    ${cyan("htmlhost rollback")} [slug] [ver]    Make an earlier version live again (Pro)
     ${cyan("htmlhost delete")} <slug>            Delete a site
     ${cyan("htmlhost login")}                    Authenticate with an API token
     ${cyan("htmlhost whoami")}                   Show current user
@@ -59,6 +61,11 @@ const HELP = `
   ${bold("Delete options:")}
     --force, -f       Skip confirmation prompt
 
+  ${bold("Rollback:")}
+    No version:       goes back to the version before the live one
+    --force, -f       Skip confirmation prompt
+    Restoring publishes the old version again as a new version
+
   ${bold("How deploy works:")}
     No args or dir: deploys entire folder as a multi-page site
     Single file:    deploys just that file (assets auto-inlined)
@@ -177,6 +184,18 @@ export async function run(argv) {
         await deleteSite(args);
         break;
       }
+      case "versions":
+      case "history": {
+        const { versions } = await import("./commands/versions.mjs");
+        await versions(args, { json: jsonMode });
+        break;
+      }
+      case "rollback":
+      case "restore": {
+        const { rollback } = await import("./commands/versions.mjs");
+        await rollback(args, { json: jsonMode });
+        break;
+      }
       case "open": {
         const { open } = await import("./commands/open.mjs");
         await open(args);

package/src/commands/clone.mjs

@@ -137,6 +137,13 @@ export async function clone(args) {
     ok(`${cyan(asset.path)} ${dim(`(${formatBytes(asset.sizeBytes)})`)}`);
   }
 
+  // --- Redirects from a deployed _redirects file ---
+  if (data.redirectsFile) {
+    writeFileSync(join(destDir, "_redirects"), data.redirectsFile, "utf8");
+    written++;
+    ok(`${cyan("_redirects")} ${dim(`(${data.redirectsFile.trim().split("\n").length} redirects)`)}`);
+  }
+
   // --- Write .htmlhost link file ---
   // A clone is always the whole site as a folder, so it links in directory
   // mode whatever the page count — `deploy` then updates this same site.

package/src/commands/deploy.mjs

@@ -1,4 +1,4 @@
-import { readFileSync, statSync, readdirSync } from "node:fs";
+import { readFileSync, statSync, readdirSync, existsSync } from "node:fs";
 import { basename, resolve, dirname, join } from "node:path";
 import { createInterface } from "node:readline";
 import { createHash } from "node:crypto";
@@ -7,6 +7,7 @@ import { ok, err, info, warn, cyan, dim, bold, yellow, green, formatBytes, mimeF
 import { checkRemoteChanges } from "./pull.mjs";
 import { fetchAgentGuide, hasAgentGuide, writeAgentGuide } from "./agents.mjs";
 import { readLink, writeLink, directorySite, directoryDeploySlug, fileDeploySlug } from "../link.mjs";
+import { sharedDrift } from "../shared-blocks.mjs";
 
 /**
  * Upload a file to a presigned URL with automatic retry.
@@ -77,6 +78,8 @@ const DEFAULT_IGNORE = [
   ".cursorrules",
   ".windsurfrules",
   ".github",
+  // Redirect rules: sent with the deploy and applied by htmlhost, never published as a file.
+  "_redirects",
 ];
 
 /**
@@ -388,6 +391,27 @@ async function deployDirectory(dirPath, { ttl, title, slug: explicitSlug, forceN
     console.log("");
   }
 
+  // Shared header/footer copies that drifted apart (edited on one page only).
+  const drift = sharedDrift(htmlFiles.map((f) => ({ path: pagePathForFile(f.relativePath), html: readFileSync(f.filePath, "utf8") })));
+  for (const d of drift) {
+    const [main, ...others] = d.groups;
+    const odd = others.flat();
+    warn(`The shared ${bold(d.name)} differs on ${odd.length} page${odd.length === 1 ? "" : "s"}: ${odd.join(", ")} (vs ${main.length} matching).`);
+    console.log(`   ${dim("Make the same change on every page that has it, or open the site in the htmlhost editor to apply one version everywhere.")}`);
+  }
+  if (drift.length) console.log("");
+
+  // Redirect rules (Netlify-style `_redirects`): sent with the deploy, where
+  // they replace the site's rules from this file. Rules added in the dashboard
+  // stay. No file, no change.
+  const redirectsPath = join(dirPath, "_redirects");
+  const redirectsText = existsSync(redirectsPath) ? readFileSync(redirectsPath, "utf8") : null;
+  if (redirectsText !== null) {
+    const lines = redirectsText.split(/\r?\n/).filter((l) => l.trim() && !l.trim().startsWith("#")).length;
+    console.log(`  ${dim("↪")} ${bold("_redirects")} ${dim(`(${lines} rule${lines === 1 ? "" : "s"})`)}`);
+    console.log("");
+  }
+
   // Confirmation prompt
   const confirmed = await promptConfirm(
     existingSlug
@@ -496,6 +520,7 @@ async function deployDirectory(dirPath, { ttl, title, slug: explicitSlug, forceN
   info(existingSlug ? `Deploying to ${cyan(existingSlug)}…` : "Deploying new site…");
 
   const body = { pages: pagePayloads, assets: assetPayloads };
+  if (redirectsText !== null) body.redirects = redirectsText;
   if (ttl) body.ttl = ttl;
   if (existingSlug) {
     body.slug = existingSlug;
@@ -538,6 +563,13 @@ async function deployDirectory(dirPath, { ttl, title, slug: explicitSlug, forceN
       console.log(`   ${cyan(`https://${data.url}${urlPath}`)}`);
     }
     console.log("");
+    if (data.redirects) {
+      const { applied, problems } = data.redirects;
+      ok(`${applied} redirect${applied === 1 ? "" : "s"} from ${bold("_redirects")} applied`);
+      for (const p of problems.slice(0, 10)) warn(p);
+      if (problems.length > 10) console.log(`   ${dim(`… and ${problems.length - 10} more`)}`);
+      console.log("");
+    }
     console.log(`   ${dim("Linked → .htmlhost")}`);
     const guide = await agentGuide;
     if (guide) writeAgentGuide(dirPath, guide, { claude: false });

package/src/commands/pull.mjs

@@ -184,6 +184,19 @@ export async function pull(args) {
     }
   }
 
+  // --- Redirects from a deployed _redirects file ---
+  if (data.redirectsFile) {
+    const localPath = join(projectDir, "_redirects");
+    const diff = diffFile(localPath, data.redirectsFile);
+    if (diff) {
+      changes.push({
+        file: "_redirects",
+        ...diff,
+        write: () => writeFileSync(localPath, data.redirectsFile, "utf8"),
+      });
+    }
+  }
+
   // --- Show results ---
   if (changes.length === 0) {
     ok("Already up to date — no changes to pull.");

package/src/commands/versions.mjs

@@ -0,0 +1,130 @@
+import { get, post } from "../api.mjs";
+import { ok, err, info, warn, dim, cyan, bold, confirm, formatBytes } from "../ui.mjs";
+import { readLink } from "../link.mjs";
+
+/** Explicit slug argument first, then the folder's .htmlhost link. */
+function resolveSlug(positional) {
+  return positional[0] || readLink(process.cwd())?.site?.slug || null;
+}
+
+function when(iso) {
+  const d = new Date(iso);
+  return d.toLocaleString("en-GB", { day: "numeric", month: "short", year: "numeric", hour: "2-digit", minute: "2-digit" });
+}
+
+function pad(str, width) {
+  const s = String(str);
+  const visible = s.replace(/\x1b\[[0-9;]*m/g, "");
+  return s + " ".repeat(Math.max(0, width - visible.length));
+}
+
+/**
+ * htmlhost versions [slug] [--json]
+ * Lists a site's published versions, newest first.
+ */
+export async function versions(args, { json = false } = {}) {
+  const positional = args.filter((a) => !a.startsWith("-"));
+  const slug = resolveSlug(positional);
+  if (!slug) {
+    err("No site given and no .htmlhost link here.");
+    console.log(`  Usage: ${cyan("htmlhost versions")} [slug]`);
+    process.exit(1);
+  }
+
+  const data = await get(`/api/sites/${encodeURIComponent(slug)}/versions`);
+  if (json) {
+    console.log(JSON.stringify(data, null, 2));
+    return;
+  }
+
+  console.log();
+  console.log(`  ${bold("Versions of")} ${cyan(`${data.slug}.htmlhost.co`)}`);
+  console.log();
+  if (!data.versions.length) {
+    console.log(dim("  No versions yet. Your next deploy will be the first."));
+    return;
+  }
+  for (const v of data.versions) {
+    const tag = v.live ? cyan(" live") : "";
+    const name = v.label ? bold(v.label) : v.summary;
+    const by = v.createdBy ? ` · ${v.createdBy}` : "";
+    console.log(`  ${pad(bold(`v${v.version}`), 6)}${tag} ${name}`);
+    console.log(dim(`        ${when(v.createdAt)} · ${v.source}${by} · ${v.pageCount} page${v.pageCount === 1 ? "" : "s"}, ${formatBytes(v.totalBytes)}`));
+  }
+  console.log();
+  if (data.usable) {
+    console.log(dim(`  Restore one with: htmlhost rollback ${data.slug} <version>`));
+  } else {
+    warn("Restoring earlier versions needs Pro: https://htmlhost.co/pricing");
+  }
+}
+
+/**
+ * htmlhost rollback [slug] [version] [--force]
+ * Publishes an earlier version again. Without a version, goes back to the one
+ * before the live version.
+ */
+export async function rollback(args, { json = false } = {}) {
+  const positional = args.filter((a) => !a.startsWith("-"));
+  const force = args.includes("--force") || args.includes("-f");
+  const isVersion = (s) => /^v?\d+$/i.test(s ?? "");
+
+  // `rollback 4`, `rollback my-site`, `rollback my-site 4`
+  let slugArg = null;
+  let versionArg = null;
+  if (positional.length >= 2) [slugArg, versionArg] = positional;
+  else if (isVersion(positional[0])) versionArg = positional[0];
+  else slugArg = positional[0] ?? null;
+
+  const slug = resolveSlug(slugArg ? [slugArg] : []);
+  if (!slug) {
+    err("No site given and no .htmlhost link here.");
+    console.log(`  Usage: ${cyan("htmlhost rollback")} [slug] [version]`);
+    process.exit(1);
+  }
+
+  const data = await get(`/api/sites/${encodeURIComponent(slug)}/versions`);
+  if (!data.usable) {
+    err("Restoring earlier versions needs Pro: https://htmlhost.co/pricing");
+    process.exit(1);
+  }
+  const live = data.versions.find((v) => v.live);
+  let target;
+  if (versionArg) {
+    const n = Number(String(versionArg).replace(/^v/i, ""));
+    target = data.versions.find((v) => v.version === n);
+    if (!target) {
+      err(`Version ${n} isn't in this site's history.`);
+      process.exit(1);
+    }
+  } else {
+    target = data.versions.find((v) => !v.live && (!live || v.version < live.version));
+    if (!target) {
+      err("There's no earlier version to go back to.");
+      process.exit(1);
+    }
+  }
+  if (target.live) {
+    info(`v${target.version} is already live.`);
+    return;
+  }
+
+  if (!force && !json) {
+    const yes = await confirm(`  Make v${target.version} (${when(target.createdAt)}) live again on ${cyan(bold(`${data.slug}.htmlhost.co`))}?`);
+    if (!yes) {
+      console.log("  Cancelled.");
+      return;
+    }
+  }
+
+  const result = await post(`/api/sites/${encodeURIComponent(data.slug)}/versions/${target.version}/restore`, {});
+  if (json) {
+    console.log(JSON.stringify(result, null, 2));
+    return;
+  }
+  const url = result.url ? (String(result.url).startsWith("http") ? result.url : `https://${result.url}`) : `https://${data.slug}.htmlhost.co`;
+  ok(`Restored v${target.version} → ${cyan(url)}`);
+  if (readLink(process.cwd())?.site?.slug === data.slug) {
+    console.log(dim(`  Your local files still have the newer version. Run ${cyan("htmlhost pull")} to match the site.`));
+  }
+}

package/src/shared-blocks.mjs

@@ -0,0 +1,77 @@
+/**
+ * Shared header/footer check for deploys.
+ * Embedded styles, font links and data-URL scripts are part of each copy and
+ * must be compared and deployed intact, just like linked shared assets.
+ *
+ * Pages can share a header and footer by wrapping them in marker comments
+ * (`<!-- hh:shared header … -->` … `<!-- /hh:shared header -->`); the htmlhost
+ * editor keeps the copies identical. When a project is edited elsewhere (an
+ * editor, an AI agent), copies can drift apart. `deploy` warns about that
+ * before uploading. This mirrors the editor's comparison (src/lib/shared-blocks.ts
+ * in the app): copies may differ only in the current page's menu link and in
+ * relative vs root paths.
+ */
+
+const OPEN = /<!--\s*hh:shared\s+([a-z][a-z0-9-]*)((?:\s+[a-z][a-z0-9-]*="[^"]*")*)\s*-->/gi;
+
+/** The first well-formed block of each name on a page: { name, attrs, content }. */
+export function findSharedBlocks(html) {
+  const blocks = [];
+  for (const open of html.matchAll(OPEN)) {
+    const name = open[1].toLowerCase();
+    if (blocks.some((b) => b.name === name)) continue;
+    const start = open.index + open[0].length;
+    const close = new RegExp(`<!--\\s*/hh:shared\\s+${name}\\s*-->`, "i").exec(html.slice(start));
+    if (!close) continue;
+    const attrs = {};
+    for (const m of open[2].matchAll(/([a-z][a-z0-9-]*)="([^"]*)"/gi)) attrs[m[1].toLowerCase()] = m[2];
+    blocks.push({ name, attrs, content: html.slice(start, start + close.index) });
+  }
+  return blocks;
+}
+
+/** Class names sites use for "you are here" (used when a marker doesn't name its own). */
+const ACTIVE_WORD = /^(is-|nav-|menu-|link-)?(active|current|selected)(-page|-item|-link)?$|^current[-_](menu|page)[-_](item|ancestor|parent)$|^router-link-(exact-)?active$|^uk-active$/i;
+
+/** A block reduced to what must match across pages. */
+export function comparable(content, attrs, pagePath) {
+  const named = (attrs["active-class"] ?? "").split(/\s+/).filter(Boolean);
+  const isActive = "active-class" in attrs ? (c) => named.includes(c) : (c) => ACTIVE_WORD.test(c);
+  let out = content.replace(/\s+aria-current\s*=\s*("[^"]*"|'[^']*'|[^\s>]+)/gi, "");
+  out = out.replace(/\sclass\s*=\s*("([^"]*)"|'([^']*)')/gi, (m, _q, dq, sq) => {
+    const kept = (dq ?? sq).split(/\s+/).filter((c) => c && !isActive(c));
+    return kept.length ? ` class="${kept.join(" ")}"` : "";
+  });
+  // Relative URLs as root paths, so a page in a subfolder compares equal.
+  const base = new URL(pagePath.startsWith("/") ? pagePath : `/${pagePath}`, "http://site.invalid");
+  out = out.replace(/\s(href|src|poster)\s*=\s*("([^"]*)"|'([^']*)')/gi, (m, name, _q, dq, sq) => {
+    const ref = (dq ?? sq).trim();
+    if (!ref || /^([a-z][a-z0-9+.-]*:|\/|#)/i.test(ref)) return ` ${name}="${ref}"`;
+    try {
+      const u = new URL(ref, base);
+      return ` ${name}="${u.pathname}${u.search}${u.hash}"`;
+    } catch {
+      return ` ${name}="${ref}"`;
+    }
+  });
+  return out.replace(/\s+/g, " ").trim();
+}
+
+/**
+ * Shared blocks whose copies differ between pages.
+ * pages: [{ path: "/about", html }] → [{ name, groups: [["/", "/about"], ["/blog"]] }] (largest group first).
+ */
+export function sharedDrift(pages) {
+  const byName = new Map();
+  for (const page of pages) {
+    for (const block of findSharedBlocks(page.html)) {
+      const key = comparable(block.content, block.attrs, page.path);
+      const groups = byName.get(block.name) ?? new Map();
+      groups.set(key, [...(groups.get(key) ?? []), page.path]);
+      byName.set(block.name, groups);
+    }
+  }
+  return [...byName]
+    .map(([name, groups]) => ({ name, groups: [...groups.values()].sort((a, b) => b.length - a.length) }))
+    .filter((d) => d.groups.length > 1);
+}