@kaooffline/quickhost 0.1.1 → 0.2.1

package/README.md

@@ -31,7 +31,7 @@ quickhost delete --app x       remove an app now
 quickhost whoami               current login
 ```
 
-Deploy auto-detects `dist/`, `build/`, `out/`, `public/` (Vite/Astro first) and runs `npm run build` if nothing is built yet. Needs `index.html` at the publish dir root. SPA fallback included.
+Deploy auto-detects `dist/`, `dist/client/` (vinext static export), `build/`, `out/` (Next export), `.output/public/` (Nuxt), `public/` and runs your `build` script once if nothing is built yet (npm/pnpm/yarn/bun aware). Needs `index.html` at the publish dir root. Static only, SPA fallback included. SSR apps (vinext/Next/Nuxt with API routes) are rejected with a clear error — they need a Node server, not R2.
 
 ## Limits
 

package/bin/quickhost.js

@@ -1,22 +1,70 @@
 #!/usr/bin/env node
 // quickhost CLI - zero dependencies, Node 18+.
+// UI kit is hand-rolled ANSI (looks like chalk+ora+boxen, no deps so npx stays fast).
 // Usage:
 //   npx @kaooffline/quickhost register -u alice
 //   npx @kaooffline/quickhost login -u alice
 //   npx @kaooffline/quickhost deploy [--app my-app] [--dir ./dist] [--api https://api.kaooffline.top]
-//   npx @kaooffline/quickhost list | npx @kaooffline/quickhost delete --app my-app | npx @kaooffline/quickhost whoami
-import { readFileSync, writeFileSync, existsSync, statSync, readdirSync } from "node:fs";
+//   npx @kaooffline/quickhost list | delete --app my-app | whoami
+import { readFileSync, writeFileSync, existsSync, readdirSync } from "node:fs";
 import { join, relative, resolve, basename } from "node:path";
 import { homedir } from "node:os";
-import { execSync } from "node:child_process";
+import { execSync, spawn } from "node:child_process";
 
+const VERSION = "0.2.1";
+
+// ---------- tiny UI kit (no deps) ----------
+const TTY = !!process.stdout.isTTY && !process.env.NO_COLOR && process.env.TERM !== "dumb";
+const ANS = (o, c) => (TTY ? `\x1b[${o}m${c}\x1b[0m` : String(c));
+const bold = (s) => ANS(1, s);
+const dim = (s) => ANS(2, s);
+const red = (s) => ANS(31, s);
+const green = (s) => ANS(32, s);
+const yellow = (s) => ANS(33, s);
+const cyan = (s) => ANS(36, s);
+const gray = (s) => ANS(90, s);
+const SYM = TTY
+  ? { ok: "✓", err: "✗", warn: "!", arrow: "→", dot: "·", q: "◆", step: "◇" }
+  : { ok: "ok", err: "ERR", warn: "!", arrow: "->", dot: "-", q: "*", step: "-" };
+const hr = () => console.log(gray("─".repeat(Math.min(56, process.stdout.columns || 56))));
+const header = (cmd) => {
+  console.log(`${cyan(bold("quickHOST"))} ${dim("static hosting on kaooffline.top")} ${gray("v" + VERSION)}`);
+  if (cmd) console.log(`${SYM.q} ${bold(cmd)}`);
+};
+const step = (n, total, msg) => console.log(`${gray(`[${n}/${total}]`)} ${msg}`);
+const done = (msg) => console.log(`${green(SYM.ok)} ${msg}`);
+const fail = (msg) => console.error(`${red(SYM.err)} ${msg}`);
+const info = (msg) => console.log(`${cyan(SYM.arrow)} ${msg}`);
+const warn = (msg) => console.log(`${yellow(SYM.warn)} ${msg}`);
+const hint = (msg) => console.log(`  ${dim(msg)}`);
+function box(lines, accent = green) {
+  const w = Math.max(...lines.map((l) => strip(l).length));
+  const top = "╭" + "─".repeat(w + 2) + "╮";
+  const bot = "╰" + "─".repeat(w + 2) + "╯";
+  console.log(TTY ? accent(top) : top);
+  for (const l of lines) console.log(`${TTY ? accent("│") : "|"} ${l}${" ".repeat(Math.max(0, w - strip(l).length))} ${TTY ? accent("│") : "|"}`);
+  console.log(TTY ? accent(bot) : bot);
+}
+const strip = (s) => String(s).replace(/\x1b\[\d+m/g, "");
+const fmtBytes = (n) => (n < 1024 ? `${n} B` : n < 1024 ** 2 ? `${(n / 1024).toFixed(1)} KB` : `${(n / 1024 ** 2).toFixed(1)} MB`);
+const bar = (i, total, w = 18) => {
+  const f = Math.round((i / total) * w);
+  return (TTY ? cyan("█".repeat(f)) : "#".repeat(f)) + gray("─".repeat(Math.max(0, w - f)));
+};
+function errBox(title, hints = []) {
+  console.log(`${red(SYM.err + " " + title)}`);
+  for (const h of hints) hint(h);
+}
+
+// ---------- config / args ----------
 const CFG = join(homedir(), ".quickhost.json");
 const load = () => { try { return JSON.parse(readFileSync(CFG, "utf8")); } catch { return {}; } };
 const save = (c) => writeFileSync(CFG, JSON.stringify(c, null, 2));
 const arg = (k, d = null) => {
   const i = process.argv.indexOf(k);
-  return i >= 0 && process.argv[i + 1] ? process.argv[i + 1] : d;
+  return i >= 0 && process.argv[i + 1] && !process.argv[i + 1].startsWith("--") ? process.argv[i + 1] : d;
 };
+const has = (...ks) => ks.some((k) => process.argv.includes(k));
 const apiBase = () => (arg("--api") || process.env.QUICKHOST_API || load().api || "https://api.kaooffline.top").replace(/\/$/, "");
 const authH = () => { const t = load().token; return t ? { authorization: "Bearer " + t } : {}; };
 
@@ -45,8 +93,9 @@ async function prompt(q) {
 }
 
 async function registerOrLogin(mode) {
+  header(mode === "register" ? "Claim your username" : "Log in");
   const u = (arg("-u") || arg("--username") || "").toLowerCase().trim();
-  if (!u) { console.error(`Usage: quickhost ${mode} -u <username>`); process.exit(1); }
+  if (!u) { errBox(`Usage: quickhost ${mode} -u <username>`); process.exit(1); }
   const p = arg("-p") || arg("--password") || await promptSecret("password: ");
   const body = { username: u, password: p };
   if (mode === "register") {
@@ -54,12 +103,22 @@ async function registerOrLogin(mode) {
     const p2 = (arg("-p") || arg("--password")) ? p : await promptSecret("password again: ");
     body.password2 = p2;
   }
-  const r = await fetch(`${apiBase()}/api/${mode}`, { method: "POST", headers: { "content-type": "application/json" }, body: JSON.stringify(body) });
-  const j = await r.json().catch(() => ({}));
-  if (!r.ok) { console.error("ERR:", j.error || r.status); process.exit(1); }
-  if (j.verify === "email-sent") { console.log(`ok: verification mail sent to ${j.email}. Click the link, then: quickhost login -u ${u}`); return; }
+  let r, j;
+  try {
+    r = await fetch(`${apiBase()}/api/${mode}`, { method: "POST", headers: { "content-type": "application/json" }, body: JSON.stringify(body) });
+    j = await r.json().catch(() => ({}));
+  } catch (e) {
+    errBox("API unreachable", [`tried ${apiBase()}`, "check network, or pass --api <url>", String(e.cause?.message || e.message || e)]);
+    process.exit(1);
+  }
+  if (!r.ok) { errBox(j.error || ("http " + r.status)); process.exit(1); }
+  if (j.verify === "email-sent") {
+    done(`verification mail sent to ${bold(j.email)}`);
+    hint("click the link, then run:"); hint(`  quickhost login -u ${u}`);
+    return;
+  }
   save({ ...load(), api: apiBase(), username: j.username, token: j.token });
-  console.log(`ok: logged in as ${j.username}`);
+  done(`logged in as ${bold(j.username)}`);
 }
 
 function walk(dir, out = [], root = dir) {
@@ -70,79 +129,306 @@ function walk(dir, out = [], root = dir) {
   }
   return out;
 }
-function detectDir() {
-  const manual = arg("--dir") || arg("-d");
-  if (manual) return resolve(manual);
-  for (const c of ["dist", "build", "out", "public", "."]) {
+
+function readPkg() {
+  try { return JSON.parse(readFileSync(join(process.cwd(), "package.json"), "utf8")); }
+  catch { return null; }
+}
+
+// Framework detection: which builder produced this project, and can it be static?
+function detectFramework(pkg) {
+  const deps = { ...(pkg?.dependencies || {}), ...(pkg?.devDependencies || {}) };
+  const hasDep = (...ns) => ns.some((n) => n in deps);
+  if (hasDep("vinext")) return { id: "vinext", label: "vinext (Vite + RSC/SSR)", statik: false };
+  if (hasDep("next", "nextjs")) return { id: "next", label: "Next.js (SSR by default)", statik: false };
+  if (hasDep("nuxt", "nitropack", "nitro")) return { id: "nuxt", label: "Nuxt/Nitro (SSR by default)", statik: false };
+  if (hasDep("@sveltejs/kit")) return { id: "sveltekit", label: "SvelteKit (SSR by default)", statik: false };
+  if (hasDep("@remix-run/node", "@react-router/node")) return { id: "remix", label: "Remix/React Router (SSR)", statik: false };
+  if (hasDep("astro")) return { id: "astro", label: "Astro", statik: true };
+  if (hasDep("vite", "@vitejs/plugin-react", "vue", "svelte")) return { id: "vite", label: "Vite", statik: true };
+  return { id: "static", label: "static html", statik: true };
+}
+
+// Publish-dir candidates in priority order. dist/client = vinext static export,
+// .output/public = Nuxt/Nitro static, out = Next export.
+const CANDIDATES = ["dist", "dist/client", "build", "out", ".output/public", "public"];
+function findBuiltDir() {
+  for (const c of CANDIDATES) {
     if (existsSync(join(process.cwd(), c, "index.html"))) return resolve(join(process.cwd(), c));
   }
-  // try build once
-  try {
-    const pkg = JSON.parse(readFileSync(join(process.cwd(), "package.json"), "utf8"));
-    if (pkg.scripts?.build) {
-      console.log("no dist/ found, running build:", pkg.scripts.build);
-      execSync("npm run build", { stdio: "inherit" });
-      for (const c of ["dist", "build", "out"]) {
-        if (existsSync(join(process.cwd(), c, "index.html"))) return resolve(join(process.cwd(), c));
+  if (existsSync(join(process.cwd(), "index.html"))) return resolve(process.cwd());
+  return null;
+}
+
+function serverHints(pkg) {
+  const hits = [];
+  const deps = { ...(pkg?.dependencies || {}), ...(pkg?.devDependencies || {}) };
+  for (const d of ["app/api", "pages/api", "src/pages/api", "server", "worker", "functions", "api"]) {
+    if (existsSync(join(process.cwd(), d))) hits.push(d + "/");
+  }
+  for (const k of Object.keys(deps)) {
+    if (/^(express|fastify|hono|drizzle-orm|prisma|kysely|pg|sqlite|better-sqlite3)/.test(k)) { hits.push(`dep:${k}`); break; }
+  }
+  return hits;
+}
+
+function pm() {
+  if (existsSync(join(process.cwd(), "bun.lock")) || existsSync(join(process.cwd(), "bun.lockb"))) return { run: "bun run build", name: "bun" };
+  if (existsSync(join(process.cwd(), "pnpm-lock.yaml"))) return { run: "pnpm run build", name: "pnpm" };
+  if (existsSync(join(process.cwd(), "yarn.lock"))) return { run: "yarn build", name: "yarn" };
+  return { run: "npm run build", name: "npm" };
+}
+
+function ssrError(fw, hints, checked) {
+  errBox("No static output found — this looks like a server app, not a static site.");
+  console.log("");
+  console.log(`  detected  ${bold(fw.label)}`);
+  if (hints.length) console.log(`  server bits ${dim(hints.slice(0, 4).join("  "))}`);
+  console.log(`  checked   ${dim(checked.join("  ") + "  (need index.html at dir root)")}`);
+  console.log("");
+  console.log(`  ${bold("quickHOST hosts static files only")} (index.html + js/css/assets).`);
+  console.log(`  ${dim("API routes, DB calls, headers()/cookies() need a Node server —")}`);
+  console.log(`  ${dim("they can't run from R2 (same reason your build lists λ API routes).")}`);
+  console.log("");
+  console.log(`  ${bold("Fix A — static export (if your pages allow it):")}`);
+  if (fw.id === "vinext") {
+    hint("vinext: configure a static export so the build emits dist/client/index.html,");
+    hint("then:  quickhost deploy --app <name> --dir ./dist/client");
+  } else if (fw.id === "next") {
+    hint("next.config: set output: 'export', rebuild, then deploy the out/ dir:");
+    hint("  quickhost deploy --app <name> --dir ./out");
+  } else if (fw.id === "nuxt") {
+    hint("run: npx nuxt generate   then:  quickhost deploy --app <name> --dir ./.output/public");
+  } else {
+    hint("build a static bundle (vite build / astro build), then:");
+    hint("  quickhost deploy --app <name> --dir ./dist");
+  }
+  console.log("");
+  console.log(`  ${bold("Fix B — keep the server, host it elsewhere:")}`);
+  hint("this app wants wrangler / Vercel / a VPS (it has a worker/, DB, /api/*).");
+  hint("quickHOST is the wrong host for it — use `vinext start` / `wrangler deploy`.");
+}
+
+// Run the project's build quietly: live one-line status, full log only on failure.
+// Pass --verbose to stream the raw build output (old behavior, for debugging).
+function runBuild(cmd, { verbose }) {
+  if (verbose) {
+    const t0 = Date.now();
+    try {
+      execSync(cmd, { stdio: "inherit" });
+      return Promise.resolve({ code: 0, log: "", secs: (Date.now() - t0) / 1000 });
+    } catch (e) {
+      return Promise.resolve({ code: e.status ?? 1, log: "", secs: (Date.now() - t0) / 1000 });
+    }
+  }
+  return new Promise((resolve) => {
+    const t0 = Date.now();
+    const child = spawn(cmd, { shell: true, stdio: ["ignore", "pipe", "pipe"] });
+    let log = "";
+    let last = "";
+    const tick = TTY ? setInterval(() => {
+      const s = ((Date.now() - t0) / 1000).toFixed(0);
+      const tail = last ? dim("  " + last.slice(0, 72)) : "";
+      process.stdout.write(`\r${cyan("…")} building… ${dim(s + "s")}${tail}   `);
+    }, 250) : null;
+    if (!TTY) console.log(dim("building… (quiet — rerun with --verbose for the full log)"));
+    const sniff = (d) => {
+      log += d;
+      const lines = String(d).split("\n").map((l) => l.replace(/\x1b\[\d+m/g, "").trim()).filter(Boolean);
+      if (lines.length) last = lines[lines.length - 1];
+    };
+    child.stdout.on("data", sniff);
+    child.stderr.on("data", sniff);
+    const finish = (code) => {
+      if (tick) { clearInterval(tick); process.stdout.write("\r" + " ".repeat(110) + "\r"); }
+      resolve({ code, log, secs: (Date.now() - t0) / 1000 });
+    };
+    child.on("close", (code) => finish(code ?? 1));
+    child.on("error", (e) => { log += String(e?.message || e); finish(1); });
+  });
+}
+
+async function detectDir() {
+  const manual = arg("--dir") || arg("-d");
+  const pkg = readPkg();
+  const fw = detectFramework(pkg);
+  if (manual) {
+    const abs = resolve(manual);
+    if (existsSync(join(abs, "index.html"))) return { dir: abs, fw, built: false };
+    errBox(`--dir ${manual} has no index.html`, [`resolved: ${abs}`, "point --dir at the folder containing index.html (e.g. --dir ./dist/client)"]);
+    process.exit(1);
+  }
+  const found = findBuiltDir();
+  if (found) return { dir: found, fw, built: false };
+  // try build once (quiet by default, --verbose streams raw output)
+  if (pkg?.scripts?.build) {
+    const { run } = pm();
+    const verbose = has("--verbose");
+    console.log(`${gray("[build]")} ${dim("no built dir yet, running:")} ${bold(run)}${verbose ? "" : dim("  (quiet)")}`);
+    const { code, log, secs } = await runBuild(run, { verbose });
+    if (code !== 0) {
+      console.log("");
+      errBox(`Build failed (exit ${code}) — fix the errors, then retry.`, [`ran: ${run} (${pkg.scripts.build})`]);
+      const tail = log.split("\n").filter((l) => l.trim()).slice(-25);
+      if (tail.length && !verbose) {
+        console.log("");
+        for (const l of tail) console.log(`  ${dim(l.slice(0, 160))}`);
+        hint("full log: rerun with --verbose");
       }
+      process.exit(1);
     }
-  } catch {}
-  console.error("ERR: no index.html found. Build your app (npm run build) or pass --dir ./dist");
+    done(`build finished in ${secs.toFixed(1)}s`);
+    const again = findBuiltDir();
+    if (again) return { dir: again, fw, built: true };
+  }
+  // nothing usable -> explain, framework-aware
+  console.log("");
+  if (!fw.statik) ssrError(fw, serverHints(pkg), [...CANDIDATES, "."]);
+  else {
+    errBox("No static output found.", [
+      `checked: ${[...CANDIDATES, "."].join("  ")}  (need index.html at dir root)`,
+      pkg?.scripts?.build ? `build ran but emitted no index.html — check your output dir` : "no build script in package.json",
+      "or pass the folder explicitly:  quickhost deploy --app <name> --dir ./dist",
+    ]);
+  }
   process.exit(1);
 }
 
 async function deploy() {
+  const t0 = Date.now();
+  header("deploy");
   const cfg = load();
-  if (!cfg.token) { console.error("ERR: not logged in. Run: quickhost login -u <name>"); process.exit(1); }
+  if (!cfg.token) {
+    errBox("Not logged in.", ["run first:", "  quickhost login -u <name>"]);
+    process.exit(1);
+  }
   let app = (arg("--app") || arg("-a") || "").toLowerCase().trim();
   if (!app) {
     try { app = basename(resolve(process.cwd())).toLowerCase().replace(/[^a-z0-9-]/g, "").slice(0, 40); }
     catch {}
   }
-  if (!/^[a-z0-9-]{1,40}$/.test(app)) { console.error("ERR: bad app name, use --app my-app"); process.exit(1); }
-  const dir = detectDir();
+  if (!/^[a-z0-9-]{1,40}$/.test(app)) { errBox("Bad app name — use --app my-app  (a-z 0-9 -, max 40)"); process.exit(1); }
+
+  const TOTAL = 3;
+  step(1, TOTAL, `locating static output ${dim(`(${cfg.username}/${app})`)}`);
+  const { dir, fw, built } = await detectDir();
+  info(`${dim("dir")} ${bold(relative(process.cwd(), dir) || ".")}  ${dim("·")} ${dim(fw.label)}${built ? dim(" · just built") : ""}`);
+
+  step(2, TOTAL, "collecting files");
   const files = walk(dir).filter((f) => !f.rel.startsWith("."));
-  if (!files.length) { console.error("ERR: empty dir", dir); process.exit(1); }
-  if (files.length > 500) { console.error("ERR: >500 files (limit)"); process.exit(1); }
+  if (!files.length) { errBox(`Empty dir: ${dir}`); process.exit(1); }
+  if (files.length > 500) { errBox(`Too many files (${files.length} > 500 limit).`, ["split into two apps, or vendor less into dist/"]); process.exit(1); }
+  let bytes = 0;
+  for (const f of files) {
+    const { statSync } = await import("node:fs");
+    const s = statSync(f.abs);
+    bytes += s.size;
+    if (s.size > 25 * 1024 * 1024) { errBox(`File >25MB: ${f.rel} (${fmtBytes(s.size)})`); process.exit(1); }
+  }
+  done(`${bold(String(files.length))} files ${dim("·")} ${bold(fmtBytes(bytes))}`);
   try {
     const idx = readFileSync(join(dir, "index.html"), "utf8");
-    if (/(src|href)="\/(?!\/)/.test(idx))
-      console.log("note: absolute asset paths (src=\"/assets/...\") detected. Works via platform fallback, but for cleanest hosting set base:'./' in vite.config (or Astro base) and rebuild.");
+    if (/(src|href)="\/(?!\/)/.test(idx)) {
+      warn("absolute asset paths detected (src=\"/assets/…\")");
+      hint("works via platform fallback, but cleanest is base:'./' in vite.config (or Astro base) + rebuild.");
+    }
   } catch {}
-  console.log(`deploying ${files.length} files from ${dir} as ${cfg.username}/${app} ...`);
-  const t0 = Date.now();
+
+  step(3, TOTAL, `uploading ${dim("→ " + apiBase())}`);
+  const base = apiBase();
   let i = 0;
   for (const f of files) {
     const buf = readFileSync(f.abs);
-    if (buf.length > 25 * 1024 * 1024) { console.error("ERR: file >25MB:", f.rel); process.exit(1); }
-    const r = await fetch(`${apiBase()}/api/apps/${app}/${encodeURIComponent(f.rel).replace(/%2F/g, "/")}`, {
-      method: "PUT", headers: { ...authH(), "content-type": mime(f.rel) }, body: buf,
-    });
-    if (!r.ok) { console.error("ERR upload", f.rel, await r.text()); process.exit(1); }
-    if (++i % 20 === 0) process.stdout.write(`  ${i}/${files.length}\r`);
-  }
-  const r = await fetch(`${apiBase()}/api/apps/${app}/finalize`, { method: "POST", headers: { ...authH(), "content-type": "application/json" }, body: "{}" });
+    let r;
+    try {
+      r = await fetch(`${base}/api/apps/${app}/${encodeURIComponent(f.rel).replace(/%2F/g, "/")}`, {
+        method: "PUT", headers: { ...authH(), "content-type": mime(f.rel) }, body: buf,
+      });
+    } catch (e) {
+      process.stdout.write("\n");
+      errBox(`Network error on ${f.rel}`, [String(e.cause?.message || e.message || e), `api: ${base}`]);
+      process.exit(1);
+    }
+    if (!r.ok) { process.stdout.write("\n"); errBox(`Upload failed: ${f.rel} (http ${r.status})`, [(await r.text()).slice(0, 300)]); process.exit(1); }
+    i++;
+    process.stdout.write(`\r  ${bar(i, files.length)}  ${dim(`${i}/${files.length}`)}  ${dim(f.rel.slice(-38))}   `);
+  }
+  process.stdout.write("\n");
+  info("finalizing…");
+  let r;
+  try {
+    r = await fetch(`${base}/api/apps/${app}/finalize`, { method: "POST", headers: { ...authH(), "content-type": "application/json" }, body: "{}" });
+  } catch (e) {
+    errBox("Finalize unreachable", [String(e.cause?.message || e.message || e)]);
+    process.exit(1);
+  }
   const j = await r.json().catch(() => ({}));
-  if (!r.ok) { console.error("ERR finalize:", j.error || r.status); process.exit(1); }
-  console.log(`\nDone in ${((Date.now() - t0) / 1000).toFixed(1)}s: ${j.url}`);
-  console.log(`Expires: ${new Date(j.expires_at * 1000).toLocaleDateString()} (redeploy renews 30d)`);
+  if (!r.ok) { errBox(`Finalize failed: ${j.error || ("http " + r.status)}`); process.exit(1); }
+
+  const secs = ((Date.now() - t0) / 1000).toFixed(1);
+  console.log("");
+  box([
+    `${green(SYM.ok)} ${bold("Deployed in " + secs + "s")}`,
+    `${bold(j.url)}`,
+    `${dim(`${files.length} files · ${fmtBytes(bytes)} · expires ${new Date(j.expires_at * 1000).toLocaleDateString()} (redeploy renews 30d)`)}`,
+  ]);
+}
+
+function help() {
+  header();
+  console.log(`
+  ${bold("Usage:")} ${cyan("quickhost")} ${dim("<command> [options]")}
+
+  ${bold("Commands")}
+    ${cyan("deploy")}  [--app x] [--dir ./dist] [--api URL] [--verbose]   upload a static dir
+    ${cyan("register")} -u <name>                              claim a username
+    ${cyan("login")}    -u <name>                              log in on this machine
+    ${cyan("list")}                                           live apps + expiry
+    ${cyan("delete")}  --app x                                remove an app
+    ${cyan("whoami")}                                         current login
+
+  ${bold("Deploy")}
+    auto-finds ${dim("dist  dist/client(vinext)  build  out  .output/public  public")}
+    runs your ${dim("build")} script once if nothing is built yet (quiet — ${dim("--verbose")} streams it).
+    needs ${bold("index.html")} at the publish dir root. static only, SPA fallback on.
+
+  ${bold("Limits")}  ${dim("50MB/app · 500 files · 25MB/file · 20 apps/user · 30-day rolling expiry")}
+  ${dim("Docs: https://kaooffline.top/docs")}`);
 }
 
 const cmd = process.argv[2];
-if (cmd === "register" || cmd === "login") await registerOrLogin(cmd);
-else if (cmd === "deploy" || !cmd) await deploy();
+if (!cmd || cmd === "deploy") await deploy();
+else if (cmd === "register" || cmd === "login") await registerOrLogin(cmd);
 else if (cmd === "list") {
-  const r = await fetch(`${apiBase()}/api/apps`, { headers: authH() });
-  const j = await r.json();
-  if (!r.ok) { console.error("ERR:", j.error); process.exit(1); }
-  for (const a of j.apps || []) console.log(`${a.username}.kaooffline.top/${a.appname}  expires=${new Date(a.expires_at * 1000).toLocaleDateString()} files=${a.file_count}`);
-  if (!(j.apps || []).length) console.log("(no live apps)");
-} else if (cmd === "delete") {
+  header("apps");
+  let r;
+  try { r = await fetch(`${apiBase()}/api/apps`, { headers: authH() }); }
+  catch (e) { errBox("API unreachable", [String(e.cause?.message || e.message || e)]); process.exit(1); }
+  const j = await r.json().catch(() => ({}));
+  if (!r.ok) { errBox(j.error || ("http " + r.status)); process.exit(1); }
+  const apps = j.apps || [];
+  if (!apps.length) { info("(no live apps — deploy one with: quickhost deploy)"); process.exit(0); }
+  const rows = apps.map((a) => [`${a.username}.kaooffline.top/${a.appname}`, `expires ${new Date(a.expires_at * 1000).toLocaleDateString()}`, `${a.file_count} files`]);
+  const w0 = Math.max(...rows.map((r) => r[0].length));
+  for (const [u, e, f] of rows) console.log(`  ${cyan(bold(u))}\n    ${dim(e)} ${dim(SYM.dot)} ${dim(f)}${" ".repeat(Math.max(0, w0 - u.length))}`);
+  hint(`${apps.length} live app${apps.length === 1 ? "" : "s"}`);
+} else if (cmd === "delete" || cmd === "revoke") {
+  header("delete");
   const app = arg("--app") || arg("-a");
-  if (!app) { console.error("Usage: quickhost delete --app <name>"); process.exit(1); }
+  if (!app) { errBox("Usage: quickhost delete --app <name>"); process.exit(1); }
   const r = await fetch(`${apiBase()}/api/apps/${app}`, { method: "DELETE", headers: authH() });
-  console.log(r.ok ? "deleted" : "ERR " + (await r.text()));
+  if (r.ok) done(`deleted ${bold(app)}`);
+  else errBox("Delete failed", [(await r.text()).slice(0, 300)]);
 } else if (cmd === "whoami") {
-  const r = await fetch(`${apiBase()}/api/me`, { headers: authH() });
-  console.log(await r.text());
-} else { console.log("Usage: quickhost [register -u x|login -u x|deploy --app x --dir ./dist|list|delete --app x|whoami]"); }
+  header("whoami");
+  const c = load();
+  if (!c.username) { warn("not logged in here."); hint("run: quickhost login -u <name>"); process.exit(0); }
+  let extra = "";
+  try {
+    const r = await fetch(`${apiBase()}/api/me`, { headers: authH() });
+    extra = dim("  (" + (await r.text()).slice(0, 120) + ")");
+  } catch {}
+  done(`${bold(c.username)}  ${dim("·")}  ${dim(apiBase())}${extra ? "\n" + extra : ""}`);
+} else if (cmd === "--help" || cmd === "-h" || cmd === "help") help();
+else if (cmd === "--version" || cmd === "-v" || cmd === "version") console.log(`quickhost v${VERSION}`);
+else { errBox(`Unknown command: ${cmd}`); help(); process.exit(1); }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kaooffline/quickhost",
-  "version": "0.1.1",
+  "version": "0.2.1",
   "description": "quickHOST CLI - one-command static hosting (Vite/Astro/HTML) to username.kaooffline.top/app. Free, 30-day rolling expiry.",
   "type": "module",
   "bin": { "quickhost": "bin/quickhost.js" },