htmlhost-cli 1.5.0 → 1.6.0

package/package.json

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

package/src/cli.mjs

@@ -4,7 +4,7 @@
 import { bold, dim, cyan, err } from "./ui.mjs";
 import { ApiError } from "./api.mjs";
 
-const VERSION = "1.5.0";
+const VERSION = "1.6.0";
 
 const HELP = `
   ${bold("htmlhost")} ${dim(`v${VERSION}`)} — deploy HTML from the terminal

package/src/commands/deploy.mjs

@@ -50,10 +50,11 @@ function promptChoice(question, options) {
 }
 
 /**
- * htmlhost deploy [file|dir] [--ttl 7d] [--slug existing-slug] [--title "My Site"] [--new] [--no-assets]
+ * htmlhost deploy [file|dir] [--ttl 7d] [--slug existing-slug] [--title "My Site"] [--new] [--no-assets] [--pages]
  *
  * - Defaults to index.html in the current directory
  * - If a directory (or ".") is given, deploys all *.html files as separate linked sites
+ * - Use --pages with a directory to deploy all *.html files as pages within ONE multi-page site
  * - Remembers the site(s) via .htmlhost file (auto re-deploy)
  * - Use --new to force fresh deploys
  */
@@ -64,6 +65,7 @@ export async function deploy(args) {
   const title = getFlag(args, "--title");
   const forceNew = args.includes("--new");
   const skipAssets = args.includes("--no-assets");
+  const multiPage = args.includes("--pages");
 
   // Check if the target is a directory
   if (file) {
@@ -71,6 +73,9 @@ export async function deploy(args) {
     try {
       const stat = statSync(filePath);
       if (stat.isDirectory()) {
+        if (multiPage) {
+          return deployMultiPage(filePath, { ttl, title, forceNew, skipAssets });
+        }
         return deployDirectory(filePath, { ttl, forceNew, skipAssets });
       }
     } catch {
@@ -78,6 +83,11 @@ export async function deploy(args) {
     }
   }
 
+  // --pages without explicit dir defaults to cwd
+  if (multiPage && !file) {
+    return deployMultiPage(resolve("."), { ttl, title, forceNew, skipAssets });
+  }
+
   // Default to index.html in the current directory
   if (!file) {
     const defaultFile = resolve("index.html");
@@ -101,13 +111,31 @@ export async function deploy(args) {
 async function deploySingleFile(file, { ttl, title, forceNew, skipAssets, slug }) {
   const filePath = resolve(file);
   const projectDir = dirname(filePath);
+  const fileName = basename(filePath);
 
   let isLinked = false;
 
   if (!slug && !forceNew) {
     const link = readLink(projectDir);
-    // Only use single-file link format (has slug at top level, not sites map)
-    if (link?.slug && !link.sites) {
+
+    if (link?.sites) {
+      // Multi-file format — warn that only one file is being deployed
+      const siteCount = Object.keys(link.sites).length;
+      if (siteCount > 1) {
+        console.log("");
+        console.log(`  ${yellow("⚠")}  This project has ${bold(String(siteCount))} linked sites but you're deploying only ${cyan(fileName)}.`);
+        console.log(`     ${dim(`To deploy all files, run: ${bold("htmlhost deploy .")}`)}`);
+        console.log("");
+      }
+      // Look up this file's entry in the sites map
+      const entry = link.sites[fileName];
+      if (entry?.slug) {
+        slug = entry.slug;
+        isLinked = true;
+        info(`Linked to ${cyan(slug)} ${dim(`(via .htmlhost sites map)`)}`);
+      }
+    } else if (link?.slug) {
+      // Single-file format (has slug at top level, no sites map)
       if (link.onRedeploy === "overwrite") {
         slug = link.slug;
         isLinked = true;
@@ -186,13 +214,21 @@ async function deploySingleFile(file, { ttl, title, forceNew, skipAssets, slug }
 
   const data = await post("/api/sites", body);
 
-  // Save/update the link (preserve onRedeploy preference)
+  // Save/update the link — merge into existing .htmlhost instead of clobbering
   const existingLink = readLink(projectDir);
-  writeLink(projectDir, {
-    slug: data.slug,
-    url: data.url,
-    ...(existingLink?.onRedeploy ? { onRedeploy: existingLink.onRedeploy } : {}),
-  });
+
+  if (existingLink?.sites) {
+    // Multi-file format: merge this file's entry into the existing sites map
+    existingLink.sites[fileName] = { slug: data.slug, url: data.url };
+    writeLink(projectDir, existingLink);
+  } else {
+    // Single-file format: write the flat slug/url (preserve onRedeploy preference)
+    writeLink(projectDir, {
+      slug: data.slug,
+      url: data.url,
+      ...(existingLink?.onRedeploy ? { onRedeploy: existingLink.onRedeploy } : {}),
+    });
+  }
 
   console.log("");
   ok(`${bold("Live")} at ${cyan(`https://${data.url}`)}`);
@@ -355,6 +391,144 @@ async function deployDirectory(dirPath, { ttl, forceNew, skipAssets }) {
   console.log("");
 }
 
+/**
+ * Deploy all *.html files in a directory as pages within a single multi-page site.
+ * Uses the --pages flag. File names map to URL paths:
+ *   index.html → /
+ *   about.html → /about
+ *   blog/index.html → /blog
+ *   blog/post.html → /blog/post
+ */
+async function deployMultiPage(dirPath, { ttl, title, forceNew, skipAssets }) {
+  // Find all .html files (recursive) — skip dotfiles
+  const htmlFiles = findHtmlFiles(dirPath, dirPath);
+
+  if (htmlFiles.length === 0) {
+    err("No .html files found in this directory.");
+    process.exit(1);
+  }
+
+  // Read existing link data
+  const link = readLink(dirPath);
+  const existingSlug = (!forceNew && link?.multipage?.slug) || null;
+
+  console.log("");
+  info(`Multi-page deploy: ${cyan(bold(String(htmlFiles.length)))} page${htmlFiles.length > 1 ? "s" : ""} in ${cyan(basename(dirPath) || ".")}`);
+  console.log("");
+
+  // Show page mapping
+  for (const { relativePath, pagePath } of htmlFiles) {
+    console.log(`   ${dim("📄")} ${relativePath} → ${cyan(pagePath)}`);
+  }
+  console.log("");
+
+  // If we have a linked slug, confirm overwrite
+  if (existingSlug) {
+    info(`Linked to ${cyan(existingSlug + ".htmlhost.co")} ${dim("(multi-page)")}`);
+  }
+
+  // Process assets and build page payloads
+  const assetCache = new Map();
+  const pagePayloads = [];
+
+  for (const { filePath, pagePath, relativePath } of htmlFiles) {
+    const stat = statSync(filePath);
+    info(`${bold(relativePath)} ${dim(`(${formatBytes(stat.size)})`)}`);
+
+    let html = readFileSync(filePath, "utf8");
+
+    if (!skipAssets) {
+      html = await processAssets(html, dirname(filePath), assetCache);
+    }
+
+    pagePayloads.push({
+      path: pagePath,
+      html,
+    });
+  }
+
+  // Deploy all pages as one multi-page site
+  const body = { pages: pagePayloads };
+  if (ttl) body.ttl = ttl;
+  if (existingSlug) body.slug = existingSlug;
+  if (title) body.title = title;
+
+  info(existingSlug ? `Re-deploying to ${cyan(existingSlug)}…` : "Deploying new multi-page site…");
+
+  try {
+    const data = await post("/api/sites", body);
+
+    // Save link
+    writeLink(dirPath, {
+      multipage: {
+        slug: data.slug,
+        url: data.url,
+        pageCount: data.pageCount || pagePayloads.length,
+      },
+    });
+
+    console.log("");
+    console.log(`  ${green("━".repeat(40))}`);
+    ok(`${bold("Live")} at ${cyan(`https://${data.url}`)}`);
+    console.log(`   ${dim(`${data.pageCount || pagePayloads.length} pages · ${data.ttl} TTL`)}`);
+    console.log("");
+
+    for (const { pagePath } of htmlFiles) {
+      const urlPath = pagePath === "/" ? "" : pagePath;
+      console.log(`   ${cyan(`https://${data.url}${urlPath}`)}`);
+    }
+    console.log("");
+    console.log(`   ${dim("Linked → .htmlhost (multipage)")}`);
+    console.log("");
+  } catch (e) {
+    err(`Deploy failed: ${e.message}`);
+    process.exit(1);
+  }
+}
+
+/**
+ * Recursively find all .html files and derive their page paths.
+ * Returns [{ filePath, relativePath, pagePath }]
+ */
+function findHtmlFiles(baseDir, currentDir) {
+  const entries = readdirSync(currentDir, { withFileTypes: true });
+  const results = [];
+
+  for (const entry of entries) {
+    if (entry.name.startsWith(".")) continue;
+
+    const fullPath = join(currentDir, entry.name);
+
+    if (entry.isDirectory()) {
+      results.push(...findHtmlFiles(baseDir, fullPath));
+    } else if (entry.name.endsWith(".html")) {
+      const relativePath = fullPath.slice(baseDir.length + 1); // e.g. "about.html" or "blog/post.html"
+
+      // Derive page path from file path
+      let pagePath;
+      if (entry.name === "index.html") {
+        // index.html → parent directory path (or "/" for root)
+        const dirRel = dirname(relativePath);
+        pagePath = dirRel === "." ? "/" : `/${dirRel}`;
+      } else {
+        // about.html → /about, blog/post.html → /blog/post
+        pagePath = "/" + relativePath.replace(/\.html$/, "");
+      }
+
+      results.push({ filePath: fullPath, relativePath, pagePath });
+    }
+  }
+
+  // Sort: root index first, then alphabetical
+  results.sort((a, b) => {
+    if (a.pagePath === "/") return -1;
+    if (b.pagePath === "/") return 1;
+    return a.pagePath.localeCompare(b.pagePath);
+  });
+
+  return results;
+}
+
 function getFlag(args, flag) {
   const idx = args.indexOf(flag);
   if (idx === -1 || idx >= args.length - 1) return null;