htmlhost-cli 2.5.0 → 2.6.1

package/package.json

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

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.5.0";
+const VERSION = "2.6.1";
 
 const HELP = `
   ${bold("htmlhost")} ${dim(`v${VERSION}`)} — deploy HTML from the terminal
@@ -16,6 +16,7 @@ const HELP = `
     ${cyan("htmlhost pull")} [slug] [opts]        Pull remote changes to local
     ${cyan("htmlhost clone")} <slug> [dir]        Clone a site to a local directory
     ${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 delete")} <slug>            Delete a site
     ${cyan("htmlhost login")}                    Authenticate with an API token
@@ -44,6 +45,13 @@ const HELP = `
     --print           Print the guide instead of writing files
     --no-claude       Don't add the @AGENTS.md import to CLAUDE.md
 
+  ${bold("Recipients subcommands:")}
+    ${cyan("recipients")} [slug]                List recipients
+    ${cyan("recipients add")} [slug] <email>    Invite a new recipient
+    ${cyan("recipients remove")} [slug] <ref>   Remove a recipient (email or id)
+    ${cyan("recipients resend")} [slug] <ref>   Resend a pending invitation
+    --force, -f       Skip confirmation on remove
+
   ${bold("Delete options:")}
     --force, -f       Skip confirmation prompt
 
@@ -138,6 +146,11 @@ export async function run(argv) {
         await agents(args);
         break;
       }
+      case "recipients": {
+        const { recipients } = await import("./commands/recipients.mjs");
+        await recipients(args, { json: jsonMode });
+        break;
+      }
       case "list":
       case "ls": {
         const { list } = await import("./commands/list.mjs");

package/src/commands/recipients.mjs

@@ -0,0 +1,270 @@
+import { get, post } from "../api.mjs";
+import { ok, err, info, dim, cyan, bold, yellow, confirm } from "../ui.mjs";
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+
+const LINK_FILE = ".htmlhost";
+
+/**
+ * Read the slug from .htmlhost in the given (or current) directory.
+ */
+function readSlugFromLink(dir = process.cwd()) {
+  const linkPath = join(dir, LINK_FILE);
+  if (!existsSync(linkPath)) return null;
+  try {
+    const data = JSON.parse(readFileSync(linkPath, "utf8"));
+    return data.multipage?.slug || data.slug || null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Resolve the slug: explicit argument first, then .htmlhost fallback.
+ */
+function resolveSlug(args) {
+  const positional = args.filter((a) => !a.startsWith("--"));
+  const explicit = positional[0];
+  if (explicit) return explicit;
+  const linked = readSlugFromLink();
+  if (linked) return linked;
+  return null;
+}
+
+/**
+ * Resolve an email-or-id argument to a recipient id by fetching the list.
+ * Returns { id, email } or null if not found.
+ */
+async function resolveRecipient(slug, ref) {
+  // Already a UUID?
+  if (/^[0-9a-f-]{36}$/i.test(ref)) {
+    return { id: ref, email: null };
+  }
+  // Treat as email — look it up
+  const data = await get(`/api/sites/${encodeURIComponent(slug)}/recipients`);
+  const match = data.recipients?.find((r) => r.email === ref.toLowerCase());
+  if (!match) return null;
+  return { id: match.id, email: match.email };
+}
+
+function statusLabel(status) {
+  switch (status) {
+    case "confirmed": return cyan("confirmed");
+    case "pending": return yellow("pending");
+    case "unsubscribed": return dim("unsubscribed");
+    default: return dim(status);
+  }
+}
+
+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));
+}
+
+function relDate(iso) {
+  if (!iso) return "";
+  const d = new Date(iso);
+  return d.toLocaleDateString("en-GB", { day: "numeric", month: "short", year: "numeric" });
+}
+
+/**
+ * htmlhost recipients [slug] [subcommand] [args] [--json] [--force]
+ */
+export async function recipients(args, { json = false } = {}) {
+  // Parse subcommand: the first non-flag arg might be a slug or a subcommand
+  const positional = args.filter((a) => !a.startsWith("--"));
+  const force = args.includes("--force") || args.includes("-f");
+
+  // Detect subcommand pattern
+  const subcommands = ["add", "remove", "resend"];
+  let subcommand = null;
+  let slug = null;
+  let subArgs = [];
+
+  if (subcommands.includes(positional[0])) {
+    // `htmlhost recipients add [slug] <email>` — subcommand first, slug from .htmlhost or second arg
+    subcommand = positional[0];
+    // Remaining positional args: could be [slug, email] or just [email]
+    subArgs = positional.slice(1);
+  } else if (positional.length >= 2 && subcommands.includes(positional[1])) {
+    // `htmlhost recipients <slug> add <email>` — slug first, then subcommand
+    slug = positional[0];
+    subcommand = positional[1];
+    subArgs = positional.slice(2);
+  } else {
+    // `htmlhost recipients [slug]` — list mode
+    slug = resolveSlug(args);
+  }
+
+  // For subcommands, resolve slug if not already set
+  if (subcommand && !slug) {
+    // subArgs might start with a slug if there are enough args
+    if (subcommand === "add" && subArgs.length >= 2) {
+      // `recipients add <slug> <email>`
+      slug = subArgs[0];
+      subArgs = subArgs.slice(1);
+    } else if ((subcommand === "remove" || subcommand === "resend") && subArgs.length >= 2) {
+      slug = subArgs[0];
+      subArgs = subArgs.slice(1);
+    } else {
+      // Try .htmlhost
+      slug = readSlugFromLink();
+    }
+  }
+
+  if (!slug) {
+    err("No site specified. Pass a slug or run from a directory with a .htmlhost file.");
+    console.log(`  ${dim("Usage:")} ${cyan("htmlhost recipients")} ${dim("[slug]")}`);
+    process.exit(1);
+  }
+
+  if (!subcommand) {
+    return listCmd(slug, json);
+  }
+
+  switch (subcommand) {
+    case "add": return addCmd(slug, subArgs, json);
+    case "remove": return removeCmd(slug, subArgs, json, force);
+    case "resend": return resendCmd(slug, subArgs, json);
+    default:
+      err(`Unknown subcommand: ${subcommand}`);
+      process.exit(1);
+  }
+}
+
+async function listCmd(slug, json) {
+  const data = await get(`/api/sites/${encodeURIComponent(slug)}/recipients`);
+
+  if (json) {
+    console.log(JSON.stringify(data));
+    return;
+  }
+
+  console.log("");
+  info(`Recipients for ${cyan(bold(slug + ".htmlhost.co"))}`);
+  console.log("");
+
+  // Owner row
+  const ownerStatus = data.notifyOwner ? cyan("receiving") : dim("off");
+  console.log(`  ${pad(data.ownerEmail, 36)} ${pad(ownerStatus, 18)} ${dim("owner")}`);
+
+  if (!data.recipients || data.recipients.length === 0) {
+    console.log("");
+    console.log(`  ${dim("No extra recipients.")}`);
+    console.log(`  ${dim("Add one with:")} ${cyan(`htmlhost recipients add ${slug} name@example.com`)}`);
+    console.log("");
+    return;
+  }
+
+  console.log(`  ${dim("─".repeat(60))}`);
+
+  for (const r of data.recipients) {
+    const status = statusLabel(r.status);
+    const forms = r.forms ? dim(`[${r.forms.join(", ")}]`) : "";
+    const invited = dim(relDate(r.invitedAt));
+    console.log(`  ${pad(r.email, 36)} ${pad(status, 18)} ${invited} ${forms}`);
+  }
+
+  const active = data.recipients.filter((r) => r.status !== "unsubscribed").length;
+  console.log("");
+  console.log(`  ${bold(String(active))}/${data.limit} recipient slots used ${dim(`(${data.isPro ? "pro" : "free"})`)}`);
+  console.log("");
+}
+
+async function addCmd(slug, subArgs, json) {
+  const email = subArgs[0];
+  if (!email) {
+    err("Usage: htmlhost recipients add [slug] <email>");
+    process.exit(1);
+  }
+
+  const res = await post(`/api/sites/${encodeURIComponent(slug)}/recipients`, {
+    action: "add",
+    email,
+  });
+
+  if (json) {
+    console.log(JSON.stringify(res));
+    return;
+  }
+
+  if (res.ok) {
+    ok(res.message || `Added ${email}.`);
+  } else {
+    err(res.error || "Failed to add recipient.");
+    process.exit(1);
+  }
+}
+
+async function removeCmd(slug, subArgs, json, force) {
+  const ref = subArgs[0];
+  if (!ref) {
+    err("Usage: htmlhost recipients remove [slug] <email|id>");
+    process.exit(1);
+  }
+
+  const resolved = await resolveRecipient(slug, ref);
+  if (!resolved) {
+    err(`Recipient not found: ${ref}`);
+    process.exit(1);
+  }
+
+  const label = resolved.email || ref;
+
+  if (!force) {
+    const yes = await confirm(`  Remove ${cyan(bold(label))} from ${cyan(slug)}?`);
+    if (!yes) {
+      console.log("  Cancelled.");
+      return;
+    }
+  }
+
+  const res = await post(`/api/sites/${encodeURIComponent(slug)}/recipients`, {
+    action: "remove",
+    id: resolved.id,
+  });
+
+  if (json) {
+    console.log(JSON.stringify(res));
+    return;
+  }
+
+  if (res.ok) {
+    ok(`Removed ${label}.`);
+  } else {
+    err(res.error || "Failed to remove recipient.");
+    process.exit(1);
+  }
+}
+
+async function resendCmd(slug, subArgs, json) {
+  const ref = subArgs[0];
+  if (!ref) {
+    err("Usage: htmlhost recipients resend [slug] <email|id>");
+    process.exit(1);
+  }
+
+  const resolved = await resolveRecipient(slug, ref);
+  if (!resolved) {
+    err(`Recipient not found: ${ref}`);
+    process.exit(1);
+  }
+
+  const res = await post(`/api/sites/${encodeURIComponent(slug)}/recipients`, {
+    action: "resend",
+    id: resolved.id,
+  });
+
+  if (json) {
+    console.log(JSON.stringify(res));
+    return;
+  }
+
+  if (res.ok) {
+    ok(res.message || `Invitation re-sent.`);
+  } else {
+    err(res.error || "Failed to resend invitation.");
+    process.exit(1);
+  }
+}