htmlhost-cli 1.0.0

package/README.md

@@ -0,0 +1,76 @@
+# htmlhost
+
+Deploy HTML files from the terminal. [htmlhost.co](https://htmlhost.co)
+
+## Install
+
+```bash
+npm i -g htmlhost
+```
+
+## Quick start
+
+```bash
+# Authenticate (get a token at htmlhost.co/settings#keys)
+htmlhost login
+
+# Deploy an HTML file
+htmlhost deploy index.html
+# → https://bold-fern-x3k.htmlhost.co
+
+# Re-deploy to the same URL
+htmlhost deploy index.html --slug bold-fern-x3k
+
+# Upload assets
+htmlhost upload logo.png
+# → https://htmlhost.co/m/a3f91c2b
+```
+
+## Commands
+
+### `htmlhost login`
+Authenticate with an API token. Generate one at [htmlhost.co/settings#keys](https://htmlhost.co/settings#keys).
+
+### `htmlhost deploy <file> [options]`
+Deploy an HTML file and get a live URL.
+
+| Option | Description |
+|---|---|
+| `--ttl <value>` | Set expiry: `1d`, `7d`, `30d`, `never` |
+| `--slug <slug>` | Re-deploy to an existing site |
+| `--title <title>` | Set the site title |
+
+### `htmlhost list`
+List all your sites with URLs, sizes, and expiry.
+
+### `htmlhost delete <slug>`
+Delete a site. Use `--force` to skip confirmation.
+
+### `htmlhost upload <file|dir>`
+Upload media assets to your library. Returns URLs you can use in your HTML.
+
+### `htmlhost whoami`
+Show current authenticated user and plan.
+
+### `htmlhost logout`
+Remove saved credentials.
+
+## Config
+
+Credentials are stored in `~/.htmlhostrc`:
+
+```json
+{
+  "token": "hh_live_...",
+  "api": "https://htmlhost.co"
+}
+```
+
+## Requirements
+
+- Node.js 18+
+- Zero dependencies
+
+## License
+
+MIT

package/bin/htmlhost.mjs

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+import { run } from "../src/cli.mjs";
+run(process.argv.slice(2));

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "htmlhost-cli",
+  "version": "1.0.0",
+  "description": "Deploy HTML files from the terminal — htmlhost.co CLI",
+  "type": "module",
+  "bin": {
+    "htmlhost": "bin/htmlhost.mjs"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "files": [
+    "bin/",
+    "src/",
+    "README.md"
+  ],
+  "keywords": [
+    "html",
+    "deploy",
+    "hosting",
+    "cli",
+    "htmlhost"
+  ],
+  "author": "htmlhost.co",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/htmlhost/cli.git"
+  }
+}

package/src/api.mjs

@@ -0,0 +1,71 @@
+/**
+ * HTTP client wrapper for the htmlhost API.
+ */
+import { getToken, getApi } from "./config.mjs";
+
+export class ApiError extends Error {
+  constructor(message, status) {
+    super(message);
+    this.status = status;
+  }
+}
+
+function headers(extra = {}) {
+  const token = getToken();
+  if (!token) throw new ApiError("Not logged in. Run: htmlhost login", 0);
+  return {
+    Authorization: `Bearer ${token}`,
+    ...extra,
+  };
+}
+
+export async function get(path) {
+  const res = await fetch(`${getApi()}${path}`, {
+    headers: headers(),
+  });
+  const data = await res.json();
+  if (!res.ok) throw new ApiError(data.error || `HTTP ${res.status}`, res.status);
+  return data;
+}
+
+export async function post(path, body) {
+  const res = await fetch(`${getApi()}${path}`, {
+    method: "POST",
+    headers: headers({ "Content-Type": "application/json" }),
+    body: JSON.stringify(body),
+  });
+  const data = await res.json();
+  if (!res.ok) throw new ApiError(data.error || `HTTP ${res.status}`, res.status);
+  return data;
+}
+
+export async function del(path) {
+  const res = await fetch(`${getApi()}${path}`, {
+    method: "DELETE",
+    headers: headers(),
+  });
+  const data = await res.json();
+  if (!res.ok) throw new ApiError(data.error || `HTTP ${res.status}`, res.status);
+  return data;
+}
+
+/**
+ * Upload a file via multipart/form-data.
+ */
+export async function uploadFile(path, filePath, fileName, mimeType) {
+  const { readFileSync } = await import("node:fs");
+  const fileBuffer = readFileSync(filePath);
+  const blob = new Blob([fileBuffer], { type: mimeType });
+
+  const form = new FormData();
+  form.append("file", blob, fileName);
+
+  const res = await fetch(`${getApi()}${path}`, {
+    method: "POST",
+    headers: { Authorization: `Bearer ${getToken()}` },
+    body: form,
+  });
+  const data = await res.json();
+  if (!res.ok) throw new ApiError(data.error || `HTTP ${res.status}`, res.status);
+  return data;
+}

package/src/cli.mjs

@@ -0,0 +1,105 @@
+/**
+ * htmlhost CLI — command router.
+ */
+import { bold, dim, cyan, err } from "./ui.mjs";
+import { ApiError } from "./api.mjs";
+
+const VERSION = "1.0.0";
+
+const HELP = `
+  ${bold("htmlhost")} ${dim(`v${VERSION}`)} — deploy HTML from the terminal
+
+  ${bold("Usage:")}
+    ${cyan("htmlhost login")}                    Authenticate with an API token
+    ${cyan("htmlhost deploy")} <file> [options]  Deploy an HTML file
+    ${cyan("htmlhost list")}                     List your sites
+    ${cyan("htmlhost delete")} <slug>            Delete a site
+    ${cyan("htmlhost upload")} <file|dir>        Upload media assets
+    ${cyan("htmlhost whoami")}                   Show current user
+    ${cyan("htmlhost logout")}                   Remove saved token
+
+  ${bold("Deploy options:")}
+    --ttl <value>     Set TTL: 1d, 7d, 30d, never
+    --slug <slug>     Re-deploy to an existing site
+    --title <title>   Set the site title
+
+  ${bold("Delete options:")}
+    --force, -f       Skip confirmation prompt
+
+  ${bold("Examples:")}
+    ${dim("$")} htmlhost deploy index.html
+    ${dim("$")} htmlhost deploy index.html --ttl 30d --title "My Portfolio"
+    ${dim("$")} htmlhost deploy build/index.html --slug my-project
+    ${dim("$")} htmlhost upload logo.png
+    ${dim("$")} htmlhost upload ./assets/
+    ${dim("$")} htmlhost delete old-project --force
+
+  ${dim(`Docs: https://htmlhost.co/docs`)}
+`;
+
+export async function run(argv) {
+  const command = argv[0];
+  const args = argv.slice(1);
+
+  if (!command || command === "--help" || command === "-h") {
+    console.log(HELP);
+    return;
+  }
+
+  if (command === "--version" || command === "-v") {
+    console.log(VERSION);
+    return;
+  }
+
+  try {
+    switch (command) {
+      case "login": {
+        const { login } = await import("./commands/login.mjs");
+        await login();
+        break;
+      }
+      case "logout": {
+        const { logout } = await import("./commands/logout.mjs");
+        logout();
+        break;
+      }
+      case "whoami": {
+        const { whoami } = await import("./commands/whoami.mjs");
+        await whoami();
+        break;
+      }
+      case "deploy": {
+        const { deploy } = await import("./commands/deploy.mjs");
+        await deploy(args);
+        break;
+      }
+      case "list":
+      case "ls": {
+        const { list } = await import("./commands/list.mjs");
+        await list();
+        break;
+      }
+      case "delete":
+      case "rm": {
+        const { deleteSite } = await import("./commands/delete.mjs");
+        await deleteSite(args);
+        break;
+      }
+      case "upload": {
+        const { upload } = await import("./commands/upload.mjs");
+        await upload(args);
+        break;
+      }
+      default:
+        err(`Unknown command: ${command}`);
+        console.log(`  Run ${cyan("htmlhost --help")} for usage.`);
+        process.exit(1);
+    }
+  } catch (e) {
+    if (e instanceof ApiError) {
+      err(e.message);
+      process.exit(1);
+    }
+    throw e;
+  }
+}

package/src/commands/delete.mjs

@@ -0,0 +1,26 @@
+import { del } from "../api.mjs";
+import { ok, err, confirm, cyan, bold } from "../ui.mjs";
+
+/**
+ * htmlhost delete <slug> [--force]
+ */
+export async function deleteSite(args) {
+  const slug = args.find((a) => !a.startsWith("--"));
+  if (!slug) {
+    err("Usage: htmlhost delete <slug>");
+    process.exit(1);
+  }
+
+  const force = args.includes("--force") || args.includes("-f");
+
+  if (!force) {
+    const yes = await confirm(`  Delete ${cyan(bold(`${slug}.htmlhost.co`))}?`);
+    if (!yes) {
+      console.log("  Cancelled.");
+      return;
+    }
+  }
+
+  await del(`/api/sites?slug=${encodeURIComponent(slug)}`);
+  ok(`Deleted ${cyan(slug)}`);
+}

package/src/commands/deploy.mjs

@@ -0,0 +1,67 @@
+import { readFileSync, statSync } from "node:fs";
+import { basename, resolve } from "node:path";
+import { post } from "../api.mjs";
+import { ok, err, info, cyan, dim, bold, formatBytes } from "../ui.mjs";
+
+/**
+ * htmlhost deploy <file> [--ttl 7d] [--slug existing-slug] [--title "My Site"]
+ */
+export async function deploy(args) {
+  const file = args.find((a) => !a.startsWith("--"));
+  if (!file) {
+    err("Usage: htmlhost deploy <file.html> [--ttl 7d] [--slug my-site]");
+    process.exit(1);
+  }
+
+  const ttl = getFlag(args, "--ttl");
+  const slug = getFlag(args, "--slug");
+  const title = getFlag(args, "--title");
+
+  const filePath = resolve(file);
+
+  // Verify file exists
+  let stat;
+  try {
+    stat = statSync(filePath);
+  } catch {
+    err(`File not found: ${file}`);
+    process.exit(1);
+  }
+
+  if (stat.isDirectory()) {
+    err("Directory deploy is not supported yet. Provide an HTML file.");
+    process.exit(1);
+  }
+
+  const html = readFileSync(filePath, "utf8");
+  const name = basename(filePath);
+
+  info(`Reading ${cyan(name)} ${dim(`(${formatBytes(stat.size)})`)}`);
+  info("Deploying…");
+
+  const body = { html };
+  if (ttl) body.ttl = ttl;
+  if (slug) body.slug = slug;
+  if (title) body.title = title;
+
+  const data = await post("/api/sites", body);
+
+  console.log("");
+  ok(`${bold("Live")} at ${cyan(`https://${data.url}`)}`);
+  if (data.version > 1) {
+    console.log(`   ${dim(`Version ${data.version} · ${data.ttl} TTL`)}`);
+  } else {
+    console.log(`   ${dim(`${data.slug} · ${data.ttl} TTL`)}`);
+  }
+  if (data.expiresAt) {
+    const d = new Date(data.expiresAt);
+    console.log(`   ${dim(`Expires ${d.toLocaleDateString()}`)}`);
+  }
+  console.log("");
+}
+
+function getFlag(args, flag) {
+  const idx = args.indexOf(flag);
+  if (idx === -1 || idx >= args.length - 1) return null;
+  return args[idx + 1];
+}

package/src/commands/list.mjs

@@ -0,0 +1,61 @@
+import { get } from "../api.mjs";
+import { dim, cyan, bold, formatBytes, yellow } from "../ui.mjs";
+
+/**
+ * htmlhost list — show all sites.
+ */
+export async function list() {
+  const data = await get("/api/sites");
+  const sites = data.sites || [];
+
+  if (sites.length === 0) {
+    console.log("");
+    console.log(`  ${dim("No sites yet.")} Deploy one with: ${cyan("htmlhost deploy index.html")}`);
+    console.log("");
+    return;
+  }
+
+  console.log("");
+
+  // Table header
+  const slugW = Math.max(20, ...sites.map((s) => s.slug.length)) + 2;
+  const hdr = [
+    pad("SLUG", slugW),
+    pad("URL", 38),
+    pad("SIZE", 10),
+    pad("TTL", 8),
+    pad("EXPIRES", 14),
+  ].join("");
+  console.log(`  ${dim(hdr)}`);
+  console.log(`  ${dim("─".repeat(hdr.length))}`);
+
+  for (const s of sites) {
+    const expires = s.expiresAt ? relTime(s.expiresAt) : "never";
+    const expiresColor = s.expiresAt && new Date(s.expiresAt) < new Date() ? yellow : dim;
+    console.log(
+      `  ${pad(cyan(s.slug), slugW)}${pad(`${s.slug}.htmlhost.co`, 38)}${pad(s.size, 10)}${pad(s.ttl, 8)}${expiresColor(expires)}`
+    );
+  }
+
+  console.log("");
+  console.log(
+    `  ${bold(String(sites.length))} sites · ${formatBytes(data.usage.totalBytes)} used` +
+    (data.usage.maxBytes ? ` / ${formatBytes(data.usage.maxBytes)}` : "") +
+    ` · ${dim(data.usage.plan)}`
+  );
+  console.log("");
+}
+
+function pad(str, width) {
+  const s = String(str);
+  return s + " ".repeat(Math.max(0, width - s.length));
+}
+
+function relTime(iso) {
+  const diff = new Date(iso) - Date.now();
+  if (diff < 0) return "expired";
+  const days = Math.floor(diff / 86400000);
+  if (days === 0) return "today";
+  if (days === 1) return "tomorrow";
+  return `${days}d`;
+}

package/src/commands/login.mjs

@@ -0,0 +1,45 @@
+import { writeConfig, getApi } from "../config.mjs";
+import { ok, err, info, dim, cyan, bold } from "../ui.mjs";
+import { createInterface } from "node:readline";
+
+export async function login() {
+  console.log("");
+  info(`Log in to ${cyan(bold("htmlhost.co"))}`);
+  console.log(`${dim("  Generate a token at")} ${getApi()}/settings#keys`);
+  console.log("");
+
+  const token = await new Promise((resolve) => {
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    rl.question(`  Paste your API token: `, (answer) => {
+      rl.close();
+      resolve(answer.trim());
+    });
+  });
+
+  if (!token) {
+    err("No token provided.");
+    process.exit(1);
+  }
+
+  // Validate the token
+  info("Verifying…");
+
+  try {
+    const res = await fetch(`${getApi()}/api/tokens/me`, {
+      headers: { Authorization: `Bearer ${token}` },
+    });
+
+    if (!res.ok) {
+      err("Invalid or expired token.");
+      process.exit(1);
+    }
+
+    const data = await res.json();
+    writeConfig({ token, api: getApi() });
+    ok(`Logged in as ${cyan(data.email)} (${data.plan})`);
+    console.log(`${dim("  Token saved to ~/.htmlhostrc")}`);
+  } catch (e) {
+    err(`Connection failed: ${e.message}`);
+    process.exit(1);
+  }
+}

package/src/commands/logout.mjs

@@ -0,0 +1,7 @@
+import { clearConfig } from "../config.mjs";
+import { ok } from "../ui.mjs";
+
+export function logout() {
+  clearConfig();
+  ok("Logged out. Token removed from ~/.htmlhostrc");
+}

package/src/commands/upload.mjs

@@ -0,0 +1,68 @@
+import { statSync, readdirSync } from "node:fs";
+import { resolve, basename, join } from "node:path";
+import { uploadFile } from "../api.mjs";
+import { ok, err, info, cyan, dim, bold, formatBytes, mimeFromExt } from "../ui.mjs";
+import { getApi } from "../config.mjs";
+
+/**
+ * htmlhost upload <file|dir> — upload media assets and get URLs.
+ */
+export async function upload(args) {
+  const target = args.find((a) => !a.startsWith("--"));
+  if (!target) {
+    err("Usage: htmlhost upload <file|directory>");
+    process.exit(1);
+  }
+
+  const targetPath = resolve(target);
+  let stat;
+  try {
+    stat = statSync(targetPath);
+  } catch {
+    err(`Not found: ${target}`);
+    process.exit(1);
+  }
+
+  const files = stat.isDirectory()
+    ? readdirSync(targetPath)
+        .filter((f) => !f.startsWith("."))
+        .map((f) => ({ path: join(targetPath, f), name: f }))
+        .filter((f) => statSync(f.path).isFile())
+    : [{ path: targetPath, name: basename(targetPath) }];
+
+  if (files.length === 0) {
+    err("No files found.");
+    process.exit(1);
+  }
+
+  console.log("");
+  info(`Uploading ${bold(String(files.length))} file${files.length > 1 ? "s" : ""}…`);
+  console.log("");
+
+  const api = getApi();
+  const results = [];
+
+  for (const file of files) {
+    const size = statSync(file.path).size;
+    const mime = mimeFromExt(file.name);
+
+    try {
+      const data = await uploadFile("/api/media", file.path, file.name, mime);
+      const url = `${api}${data.url}`;
+      results.push({ name: file.name, url, size });
+      ok(`${cyan(file.name)} ${dim(`(${formatBytes(size)})`)} → ${url}`);
+    } catch (e) {
+      err(`${file.name}: ${e.message}`);
+    }
+  }
+
+  if (results.length > 0) {
+    console.log("");
+    console.log(`  ${dim("Use these URLs in your HTML:")}`);
+    console.log("");
+    for (const r of results) {
+      console.log(`  ${dim(`<img src="${r.url}" />`)}`)
+    }
+    console.log("");
+  }
+}

package/src/commands/whoami.mjs

@@ -0,0 +1,11 @@
+import { get } from "../api.mjs";
+import { ok, cyan, dim, bold, formatBytes } from "../ui.mjs";
+
+export async function whoami() {
+  const data = await get("/api/tokens/me");
+  console.log("");
+  ok(`${cyan(bold(data.email))} ${dim(`(${data.plan})`)}`);
+  if (data.name) console.log(`   ${dim("Name:")} ${data.name}`);
+  if (data.handle) console.log(`   ${dim("Handle:")} @${data.handle}`);
+  console.log("");
+}

package/src/config.mjs

@@ -0,0 +1,41 @@
+/**
+ * Config file management — reads/writes ~/.htmlhostrc
+ */
+import { readFileSync, writeFileSync, mkdirSync, chmodSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+
+const CONFIG_PATH = join(homedir(), ".htmlhostrc");
+const DEFAULT_API = "https://htmlhost.co";
+
+export function readConfig() {
+  try {
+    const raw = readFileSync(CONFIG_PATH, "utf8");
+    return JSON.parse(raw);
+  } catch {
+    return {};
+  }
+}
+
+export function writeConfig(data) {
+  const existing = readConfig();
+  const merged = { ...existing, ...data };
+  writeFileSync(CONFIG_PATH, JSON.stringify(merged, null, 2) + "\n", "utf8");
+  try {
+    chmodSync(CONFIG_PATH, 0o600); // read/write only by owner
+  } catch { /* Windows doesn't support chmod */ }
+}
+
+export function clearConfig() {
+  try {
+    writeFileSync(CONFIG_PATH, "{}\n", "utf8");
+  } catch { /* ignore */ }
+}
+
+export function getToken() {
+  return readConfig().token || null;
+}
+
+export function getApi() {
+  return readConfig().api || DEFAULT_API;
+}

package/src/ui.mjs

@@ -0,0 +1,117 @@
+/**
+ * Terminal output helpers — colors via ANSI codes, no dependencies.
+ */
+const c = (code) => (s) => `\x1b[${code}m${s}\x1b[0m`;
+
+export const bold = c("1");
+export const dim = c("2");
+export const green = c("32");
+export const red = c("31");
+export const cyan = c("36");
+export const yellow = c("33");
+export const gray = c("90");
+export const magenta = c("35");
+
+export const ok = (msg) => console.log(`${green("✓")} ${msg}`);
+export const err = (msg) => console.error(`${red("✗")} ${msg}`);
+export const info = (msg) => console.log(`${cyan("●")} ${msg}`);
+export const warn = (msg) => console.log(`${yellow("!")} ${msg}`);
+
+/**
+ * Simple readline prompt (hidden input support).
+ */
+export async function prompt(question, { hidden = false } = {}) {
+  const { createInterface } = await import("node:readline");
+  return new Promise((resolve) => {
+    const rl = createInterface({
+      input: process.stdin,
+      output: process.stdout,
+    });
+
+    if (hidden) {
+      process.stdout.write(question);
+      const stdin = process.stdin;
+      const wasRaw = stdin.isRaw;
+      if (stdin.setRawMode) stdin.setRawMode(true);
+
+      let input = "";
+      const onData = (ch) => {
+        const c = ch.toString();
+        if (c === "\n" || c === "\r") {
+          if (stdin.setRawMode) stdin.setRawMode(wasRaw);
+          stdin.removeListener("data", onData);
+          process.stdout.write("\n");
+          rl.close();
+          resolve(input);
+        } else if (c === "\u0003") {
+          process.exit(1);
+        } else if (c === "\u007f" || c === "\b") {
+          input = input.slice(0, -1);
+        } else {
+          input += c;
+        }
+      };
+      stdin.on("data", onData);
+    } else {
+      rl.question(question, (answer) => {
+        rl.close();
+        resolve(answer);
+      });
+    }
+  });
+}
+
+/**
+ * Confirm y/N prompt.
+ */
+export async function confirm(question) {
+  const { createInterface } = await import("node:readline");
+  return new Promise((resolve) => {
+    const rl = createInterface({
+      input: process.stdin,
+      output: process.stdout,
+    });
+    rl.question(`${question} ${dim("(y/N)")} `, (answer) => {
+      rl.close();
+      resolve(answer.trim().toLowerCase() === "y");
+    });
+  });
+}
+
+/**
+ * Format bytes to human readable.
+ */
+export function formatBytes(bytes) {
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+  return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
+
+/**
+ * Detect MIME type from file extension.
+ */
+export function mimeFromExt(filename) {
+  const ext = filename.split(".").pop()?.toLowerCase();
+  const map = {
+    png: "image/png",
+    jpg: "image/jpeg",
+    jpeg: "image/jpeg",
+    gif: "image/gif",
+    svg: "image/svg+xml",
+    webp: "image/webp",
+    ico: "image/x-icon",
+    woff: "font/woff",
+    woff2: "font/woff2",
+    ttf: "font/ttf",
+    otf: "font/otf",
+    css: "text/css",
+    js: "text/javascript",
+    json: "application/json",
+    mp4: "video/mp4",
+    webm: "video/webm",
+    mp3: "audio/mpeg",
+    wav: "audio/wav",
+    pdf: "application/pdf",
+  };
+  return map[ext] || "application/octet-stream";
+}