@zerodeploy/cli 0.1.1 → 0.1.3

package/dist/cli.js

@@ -2743,6 +2743,103 @@ import http from "node:http";
 import fs6 from "fs";
 import os2 from "os";
 import path2 from "path";
+
+// src/utils/errors.ts
+function parseApiError(body) {
+  if (!body || typeof body !== "object") {
+    return {
+      code: "unknown_error",
+      message: "Unknown error occurred"
+    };
+  }
+  const response = body;
+  if (typeof response.error === "object" && response.error !== null) {
+    return response.error;
+  }
+  if (typeof response.error === "string") {
+    return {
+      code: "api_error",
+      message: response.error
+    };
+  }
+  if ("message" in response && typeof response.message === "string") {
+    return {
+      code: "api_error",
+      message: response.message
+    };
+  }
+  if ("success" in response && response.success === false) {
+    const zodError = response;
+    if (zodError.error?.issues?.[0]) {
+      const issue = zodError.error.issues[0];
+      const field = issue.path?.join(".") || "";
+      return {
+        code: "validation_error",
+        message: field ? `${field}: ${issue.message}` : issue.message
+      };
+    }
+  }
+  return {
+    code: "unknown_error",
+    message: "Unknown error occurred"
+  };
+}
+function displayError(error) {
+  if (typeof error === "string") {
+    console.error(`
+❌ ${error}
+`);
+    return;
+  }
+  console.error(`
+❌ ${error.message}`);
+  if (error.details && Object.keys(error.details).length > 0) {
+    console.error();
+    for (const [key, value] of Object.entries(error.details)) {
+      const formattedKey = key.replace(/_/g, " ").replace(/^./, (c) => c.toUpperCase());
+      console.error(`   ${formattedKey}: ${value}`);
+    }
+  }
+  if (error.hint) {
+    console.error();
+    console.error(`   Hint: ${error.hint}`);
+  }
+  if (error.docs) {
+    console.error(`   Docs: ${error.docs}`);
+  }
+  console.error();
+}
+function displayNetworkError(error) {
+  if (error.message.includes("fetch failed") || error.message.includes("ECONNREFUSED")) {
+    displayError({
+      code: "connection_error",
+      message: "Could not connect to ZeroDeploy API",
+      hint: "Check your internet connection and try again"
+    });
+  } else if (error.message.includes("timeout")) {
+    displayError({
+      code: "timeout_error",
+      message: "Request timed out",
+      hint: "Check your internet connection and try again"
+    });
+  } else {
+    displayError({
+      code: "network_error",
+      message: error.message || "Network error occurred",
+      hint: "Check your internet connection and try again"
+    });
+  }
+}
+function displayAuthError() {
+  displayError({
+    code: "unauthorized",
+    message: "Not logged in",
+    hint: "For local use: Run `zerodeploy login`\nFor CI/CD: Set ZERODEPLOY_TOKEN environment variable",
+    docs: "https://zerodeploy.dev/docs/cli/auth"
+  });
+}
+
+// src/auth/token.ts
 var DIR = path2.join(os2.homedir(), ".zerodeploy");
 var TOKEN_PATH = path2.join(DIR, "token");
 function saveToken(token) {
@@ -2780,6 +2877,7 @@ var loginCommand = new Command2("login").description("Login via GitHub OAuth wit
     if (req.url?.startsWith(CALLBACK_PATH)) {
       const url = new URL(req.url, `http://localhost:${PORT}`);
       const token = url.searchParams.get("token");
+      const pending = url.searchParams.get("pending") === "true";
       if (!token) {
         res.writeHead(400);
         res.end("Login failed: missing token");
@@ -2787,9 +2885,20 @@ var loginCommand = new Command2("login").description("Login via GitHub OAuth wit
         process.exit(1);
       }
       saveToken(token);
-      res.writeHead(200, { "Content-Type": "text/plain" });
-      res.end("✅ Login successful! You can close this window.");
-      console.log("✅ Login successful! Token saved locally.");
+      if (pending) {
+        res.writeHead(200, { "Content-Type": "text/plain" });
+        res.end("You're on the waitlist! We'll email you when your account is approved.");
+        console.log("");
+        console.log("\uD83D\uDD50 You're on the waitlist!");
+        console.log("");
+        console.log("Thanks for signing up. Your account is pending approval.");
+        console.log("We'll send you an email when you're approved.");
+        console.log("");
+      } else {
+        res.writeHead(200, { "Content-Type": "text/plain" });
+        res.end("Login successful! You can close this window.");
+        console.log("Login successful! Token saved locally.");
+      }
       server.close();
     } else {
       res.writeHead(404);
@@ -3091,16 +3200,156 @@ var hc = (baseUrl, options) => createProxy(function proxyCallback(opts) {
   return req;
 }, []);
 
+// ../../packages/api-client/src/retry.ts
+var DEFAULT_OPTIONS = {
+  maxRetries: 3,
+  baseDelayMs: 1000,
+  maxDelayMs: 1e4
+};
+var RETRYABLE_STATUS_CODES = new Set([
+  408,
+  429,
+  502,
+  503,
+  504
+]);
+function isRetryableError(error) {
+  if (!(error instanceof Error))
+    return false;
+  const message = error.message.toLowerCase();
+  if (message.includes("fetch failed"))
+    return true;
+  if (message.includes("econnrefused"))
+    return true;
+  if (message.includes("econnreset"))
+    return true;
+  if (message.includes("etimedout"))
+    return true;
+  if (message.includes("enotfound"))
+    return true;
+  if (message.includes("enetunreach"))
+    return true;
+  if (message.includes("timeout"))
+    return true;
+  if (message.includes("aborted"))
+    return true;
+  if (message.includes("ssl"))
+    return true;
+  if (message.includes("certificate"))
+    return true;
+  return false;
+}
+function isRetryableStatus(status) {
+  return RETRYABLE_STATUS_CODES.has(status);
+}
+function calculateDelay(attempt, baseDelayMs, maxDelayMs) {
+  const exponentialDelay = baseDelayMs * Math.pow(2, attempt);
+  const cappedDelay = Math.min(exponentialDelay, maxDelayMs);
+  const jitter = cappedDelay * 0.25 * (Math.random() * 2 - 1);
+  return Math.round(cappedDelay + jitter);
+}
+function getDelayFromHeaders(response) {
+  const retryAfter = response.headers.get("Retry-After");
+  if (retryAfter) {
+    const seconds = parseInt(retryAfter, 10);
+    if (!isNaN(seconds)) {
+      return seconds * 1000;
+    }
+    const date = Date.parse(retryAfter);
+    if (!isNaN(date)) {
+      return Math.max(0, date - Date.now());
+    }
+  }
+  const resetAt = response.headers.get("X-RateLimit-Reset");
+  if (resetAt) {
+    const resetTimestamp = parseInt(resetAt, 10);
+    if (!isNaN(resetTimestamp)) {
+      const delayMs = resetTimestamp * 1000 - Date.now();
+      return Math.max(1000, delayMs);
+    }
+  }
+  return null;
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function fetchWithRetry(input, init, options) {
+  const opts = { ...DEFAULT_OPTIONS, ...options };
+  let lastError;
+  for (let attempt = 0;attempt <= opts.maxRetries; attempt++) {
+    try {
+      const response = await fetch(input, init);
+      if (isRetryableStatus(response.status) && attempt < opts.maxRetries) {
+        const headerDelay = response.status === 429 ? getDelayFromHeaders(response) : null;
+        const delayMs = headerDelay ?? calculateDelay(attempt, opts.baseDelayMs, opts.maxDelayMs);
+        const cappedDelay = Math.min(delayMs, opts.maxDelayMs);
+        opts.onRetry?.(attempt + 1, response, cappedDelay);
+        await sleep(cappedDelay);
+        continue;
+      }
+      return response;
+    } catch (error) {
+      lastError = error instanceof Error ? error : new Error(String(error));
+      if (!isRetryableError(error) || attempt >= opts.maxRetries) {
+        throw lastError;
+      }
+      const delayMs = calculateDelay(attempt, opts.baseDelayMs, opts.maxDelayMs);
+      opts.onRetry?.(attempt + 1, lastError, delayMs);
+      await sleep(delayMs);
+    }
+  }
+  throw lastError ?? new Error("Max retries exceeded");
+}
+function createRetryFetch(options) {
+  return (input, init) => {
+    return fetchWithRetry(input, init, options);
+  };
+}
+function formatRetryMessage(attempt, maxRetries, error) {
+  const errorDesc = error instanceof Response ? `HTTP ${error.status}` : error.message.split(`
+`)[0];
+  return `Retry ${attempt}/${maxRetries} (${errorDesc})`;
+}
+
 // ../../packages/api-client/src/index.ts
-function createClient(baseUrl, token) {
+var DEFAULT_RETRY_OPTIONS = {
+  maxRetries: 3,
+  baseDelayMs: 1000,
+  maxDelayMs: 1e4
+};
+function createClient(baseUrl, token, options) {
+  let fetchFn = options?.fetch;
+  if (!fetchFn && options?.retry !== false) {
+    const retryOpts = typeof options?.retry === "object" ? options.retry : DEFAULT_RETRY_OPTIONS;
+    fetchFn = createRetryFetch(retryOpts);
+  }
+  if (options?.useCredentials && fetchFn) {
+    const baseFetch = fetchFn;
+    fetchFn = (input, init) => baseFetch(input, { ...init, credentials: "include" });
+  } else if (options?.useCredentials) {
+    fetchFn = (input, init) => fetch(input, { ...init, credentials: "include" });
+  }
   return hc(baseUrl, {
-    headers: token ? { Authorization: `Bearer ${token}` } : undefined
+    headers: token ? { Authorization: `Bearer ${token}` } : undefined,
+    fetch: fetchFn
   });
 }
 
 // src/auth/http.ts
-function getClient(token) {
-  return createClient(API_URL, token);
+var DEFAULT_RETRY_OPTIONS2 = {
+  maxRetries: 3,
+  baseDelayMs: 1000,
+  maxDelayMs: 1e4,
+  onRetry: (attempt, error, delayMs) => {
+    if (process.stderr.isTTY) {
+      const msg = formatRetryMessage(attempt, 3, error);
+      process.stderr.write(`\r\x1B[K  ${msg}, waiting ${Math.round(delayMs / 1000)}s...`);
+    }
+  }
+};
+function getClient(token, retryOptions) {
+  const opts = { ...DEFAULT_RETRY_OPTIONS2, ...retryOptions };
+  return createClient(API_URL, token, { retry: opts });
 }
 
 // src/commands/whoami.ts
@@ -3118,10 +3367,90 @@ var whoamiCommand = new Command2("whoami").description("Show the currently logge
     const data = await res.json();
     console.log("Logged in as:");
     console.log(`  Username: ${data.username}`);
+    console.log(`  Email:    ${data.email || "(not set)"}`);
     console.log(`  User ID:  ${data.id}`);
     console.log(`  Admin:    ${data.isAdmin ? "Yes" : "No"}`);
+    if (data.approved === false) {
+      console.log("");
+      console.log("\uD83D\uDD50 Status: Pending approval (waitlist)");
+      console.log("   We'll email you when your account is approved.");
+    }
+  } catch (err) {
+    console.error("Failed to fetch user info:", err.message || err);
+    process.exit(1);
+  }
+});
+
+// src/commands/usage.ts
+function progressBar(current, max, width = 20) {
+  const percentage = Math.min(current / max, 1);
+  const filled = Math.round(percentage * width);
+  const empty = width - filled;
+  const bar = "█".repeat(filled) + "░".repeat(empty);
+  const color = percentage >= 0.9 ? "\x1B[31m" : percentage >= 0.7 ? "\x1B[33m" : "\x1B[32m";
+  const reset = "\x1B[0m";
+  return `${color}${bar}${reset}`;
+}
+function formatUsageLine(label, current, max, suffix = "") {
+  const bar = progressBar(current, max);
+  const percentage = Math.round(current / max * 100);
+  return `  ${label.padEnd(24)} ${bar} ${current}/${max}${suffix} (${percentage}%)`;
+}
+var usageCommand = new Command2("usage").description("Show current usage and plan limits").option("--json", "Output as JSON").action(async (options) => {
+  const token = loadToken();
+  if (!token) {
+    displayAuthError();
+    process.exit(1);
+  }
+  try {
+    const client = getClient(token);
+    const res = await client.auth.me.usage.$get();
+    if (!res.ok) {
+      const body = await res.json();
+      displayError(parseApiError(body));
+      process.exit(1);
+    }
+    const data = await res.json();
+    if (options.json) {
+      console.log(JSON.stringify(data, null, 2));
+      return;
+    }
+    console.log();
+    console.log(`Plan: ${data.plan.toUpperCase()}`);
+    console.log();
+    console.log("Account Usage:");
+    console.log(formatUsageLine("Organizations", data.usage.orgs, data.limits.max_orgs));
+    console.log(formatUsageLine("Total Sites", data.usage.sites, data.limits.max_orgs * data.limits.max_sites_per_org));
+    console.log(formatUsageLine("Deployments (month)", data.usage.deployments_this_month, data.limits.max_deployments_per_month));
+    console.log();
+    console.log("Plan Limits:");
+    console.log(`  Sites per org:           ${data.limits.max_sites_per_org}`);
+    console.log(`  Deployments per day:     ${data.limits.max_deployments_per_day}`);
+    console.log(`  Deployments per month:   ${data.limits.max_deployments_per_month}`);
+    console.log(`  Max deployment size:     ${data.limits.max_deployment_size}`);
+    console.log(`  Storage per org:         ${data.limits.max_storage_per_org}`);
+    console.log(`  Deploy tokens per site:  ${data.limits.max_deploy_tokens_per_site}`);
+    console.log(`  Domains per site:        ${data.limits.max_domains_per_site}`);
+    console.log(`  API requests/min:        ${data.limits.api_requests_per_minute}`);
+    console.log(`  Deploy requests/min:     ${data.limits.deploy_requests_per_minute}`);
+    console.log();
+    if (data.orgs.length > 0) {
+      console.log("Organization Usage:");
+      for (const org of data.orgs) {
+        console.log();
+        console.log(`  ${org.name} (${org.slug}):`);
+        console.log(formatUsageLine("Sites", org.sites_count, org.limits.max_sites));
+        console.log(formatUsageLine("Deployments (month)", org.deployments_this_month, org.limits.max_deployments_per_month));
+        console.log(`    Storage:                 ${org.storage_used} / ${org.limits.max_storage}`);
+      }
+      console.log();
+    }
   } catch (err) {
-    console.error("❌ Failed to fetch user info:", err.message || err);
+    const message = err instanceof Error ? err.message : String(err);
+    displayError({
+      code: "api_error",
+      message: `Failed to fetch usage info: ${message}`
+    });
     process.exit(1);
   }
 });
@@ -3138,7 +3467,7 @@ var orgListCommand = new Command2("list").description("List your organizations")
     const res = await client.orgs.$get();
     if (!res.ok)
       throw new Error(`API Error ${res.status}`);
-    const orgs = await res.json();
+    const { data: orgs } = await res.json();
     if (orgs.length === 0) {
       console.log("No organizations found.");
     } else {
@@ -3156,7 +3485,7 @@ var orgListCommand = new Command2("list").description("List your organizations")
 var orgCreateCommand = new Command2("create").description("Create a new organization").argument("<name>", "Organization name").action(async (name) => {
   const token = loadToken();
   if (!token) {
-    console.log("❌ Not logged in. Run `zerodeploy login` first.");
+    displayAuthError();
     return;
   }
   try {
@@ -3164,16 +3493,21 @@ var orgCreateCommand = new Command2("create").description("Create a new organiza
     const res = await client.orgs.$post({ json: { name } });
     if (!res.ok) {
       const body = await res.json();
-      const message = body.error || `API Error ${res.status}`;
-      console.error(`❌ ${message}`);
+      displayError(parseApiError(body));
       return;
     }
     const org = await res.json();
-    console.log(`✅ Created org: ${org.name}`);
+    console.log(`
+✅ Created org: ${org.name}`);
     console.log(`   Slug: ${org.slug}`);
-    console.log(`   ID:   ${org.id}`);
+    console.log(`   ID:   ${org.id}
+`);
   } catch (err) {
-    console.error("Failed to create org:", err.message || err);
+    if (err instanceof Error) {
+      displayNetworkError(err);
+    } else {
+      displayError({ code: "unknown_error", message: "Failed to create org" });
+    }
   }
 });
 
@@ -3194,7 +3528,7 @@ function prompt(question) {
 var orgDeleteCommand = new Command2("delete").description("Delete an organization (must have no sites)").argument("<orgSlug>", "Organization slug").option("--force", "Skip confirmation prompt").action(async (orgSlug, options) => {
   const token = loadToken();
   if (!token) {
-    console.log("Not logged in. Run: zerodeploy login");
+    displayAuthError();
     return;
   }
   if (!options.force) {
@@ -3210,19 +3544,20 @@ var orgDeleteCommand = new Command2("delete").description("Delete an organizatio
       param: { orgSlug }
     });
     if (!res.ok) {
-      const error = await res.json();
-      if (error.hint) {
-        console.error(`Error: ${error.error}`);
-        console.error(`Hint: ${error.hint}`);
-        return;
-      }
-      throw new Error(error.error || `API Error ${res.status}`);
+      const body = await res.json();
+      displayError(parseApiError(body));
+      return;
     }
     const result = await res.json();
-    console.log(`✅ ${result.message}`);
+    console.log(`
+✅ ${result.message}
+`);
   } catch (err) {
-    const message = err instanceof Error ? err.message : "Unknown error";
-    console.error("Failed to delete organization:", message);
+    if (err instanceof Error) {
+      displayNetworkError(err);
+    } else {
+      displayError({ code: "unknown_error", message: "Failed to delete organization" });
+    }
   }
 });
 
@@ -3241,7 +3576,7 @@ var siteListCommand = new Command2("list").description("List sites in an organiz
     const res = await client.orgs[":orgSlug"].sites.$get({ param: { orgSlug } });
     if (!res.ok)
       throw new Error(`API Error ${res.status}`);
-    const sites = await res.json();
+    const { data: sites } = await res.json();
     if (sites.length === 0) {
       console.log("No sites found.");
       return;
@@ -3340,13 +3675,10 @@ var siteLinkCommand = new Command2("link").description("Link a site to a GitHub
     return;
   }
   try {
-    const res = await fetch(`${API_URL}/orgs/${orgSlug}/sites/${siteSlug}`, {
-      method: "PATCH",
-      headers: {
-        "Content-Type": "application/json",
-        Authorization: `Bearer ${token}`
-      },
-      body: JSON.stringify({ githubRepo: repo })
+    const client = getClient(token);
+    const res = await client.orgs[":orgSlug"].sites[":siteSlug"].$patch({
+      param: { orgSlug, siteSlug },
+      json: { githubRepo: repo }
     });
     if (!res.ok) {
       const error = await res.json();
@@ -3367,13 +3699,10 @@ var siteUnlinkCommand = new Command2("unlink").description("Unlink a site from i
     return;
   }
   try {
-    const res = await fetch(`${API_URL}/orgs/${orgSlug}/sites/${siteSlug}`, {
-      method: "PATCH",
-      headers: {
-        "Content-Type": "application/json",
-        Authorization: `Bearer ${token}`
-      },
-      body: JSON.stringify({ githubRepo: null })
+    const client = getClient(token);
+    const res = await client.orgs[":orgSlug"].sites[":siteSlug"].$patch({
+      param: { orgSlug, siteSlug },
+      json: { githubRepo: null }
     });
     if (!res.ok) {
       const error = await res.json();
@@ -3414,8 +3743,143 @@ var siteSubdomainCommand = new Command2("subdomain").description("Update the sub
   }
 });
 
+// src/commands/site/rename.ts
+var siteRenameCommand = new Command2("rename").description("Rename a site").argument("<siteSlug>", "Site slug").argument("<newName>", "New name for the site").requiredOption("--org <orgSlug>", "Organization slug").action(async (siteSlug, newName, options) => {
+  const token = loadToken();
+  if (!token) {
+    console.log("Not logged in. Run: zerodeploy login");
+    return;
+  }
+  try {
+    const client = getClient(token);
+    const res = await client.orgs[":orgSlug"].sites[":siteSlug"].$patch({
+      param: { orgSlug: options.org, siteSlug },
+      json: { name: newName }
+    });
+    if (!res.ok) {
+      const error = await res.json();
+      throw new Error(error.error || `API Error ${res.status}`);
+    }
+    const site = await res.json();
+    console.log(`✅ Renamed site to: ${site.name}`);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : "Unknown error";
+    console.error("Failed to rename site:", message);
+  }
+});
+
+// src/commands/site/stats.ts
+function formatBytes(bytes) {
+  if (bytes === 0)
+    return "0 B";
+  const k = 1024;
+  const sizes = ["B", "KB", "MB", "GB"];
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  return parseFloat((bytes / Math.pow(k, i)).toFixed(1)) + " " + sizes[i];
+}
+function formatNumber(n) {
+  if (n >= 1e6)
+    return (n / 1e6).toFixed(1) + "M";
+  if (n >= 1000)
+    return (n / 1000).toFixed(1) + "K";
+  return n.toString();
+}
+var siteStatsCommand = new Command2("stats").description("View site traffic analytics").argument("<site>", "Site slug").requiredOption("--org <orgSlug>", "Organization slug").option("--period <period>", "Time period: 24h, 7d, or 30d", "7d").action(async (site, options) => {
+  const token = loadToken();
+  if (!token) {
+    console.log("Not logged in. Run: zerodeploy login");
+    return;
+  }
+  const validPeriods = ["24h", "7d", "30d"];
+  if (!validPeriods.includes(options.period)) {
+    console.error(`Invalid period. Use: ${validPeriods.join(", ")}`);
+    return;
+  }
+  try {
+    const client = getClient(token);
+    const res = await client.orgs[":orgSlug"].sites[":siteSlug"].analytics.$get({
+      param: { orgSlug: options.org, siteSlug: site },
+      query: { period: options.period }
+    });
+    if (!res.ok) {
+      const error = await res.json();
+      throw new Error(error.error || `API Error ${res.status}`);
+    }
+    const data = await res.json();
+    if (!data.configured) {
+      console.log("Analytics not configured for this site.");
+      return;
+    }
+    const { overview, topPages, countries, statusCodes } = data;
+    const periodLabel = options.period === "24h" ? "Last 24 hours" : options.period === "7d" ? "Last 7 days" : "Last 30 days";
+    console.log(`Analytics for ${options.org}/${site}`);
+    console.log(`Period: ${periodLabel}`);
+    console.log();
+    console.log("Overview");
+    console.log("  " + "-".repeat(40));
+    console.log(`  Requests:        ${formatNumber(overview.totalRequests).padStart(10)}`);
+    console.log(`  Bandwidth:       ${formatBytes(overview.totalBytes).padStart(10)}`);
+    console.log(`  Unique visitors: ${formatNumber(overview.uniqueVisitors).padStart(10)}`);
+    console.log(`  Unique pages:    ${formatNumber(overview.uniquePaths).padStart(10)}`);
+    if (overview.formSubmissions > 0) {
+      console.log(`  Form submissions:${formatNumber(overview.formSubmissions).padStart(10)}`);
+    }
+    if (overview.bounceRate > 0) {
+      console.log(`  Bounce rate:     ${overview.bounceRate.toFixed(1).padStart(9)}%`);
+    }
+    console.log();
+    if (topPages.length > 0) {
+      console.log("Top Pages");
+      console.log("  " + "-".repeat(50));
+      const maxPages = 5;
+      for (const page of topPages.slice(0, maxPages)) {
+        const path3 = page.path.length > 30 ? page.path.slice(0, 27) + "..." : page.path;
+        console.log(`  ${path3.padEnd(32)} ${formatNumber(page.requests).padStart(8)} reqs`);
+      }
+      console.log();
+    }
+    if (countries.length > 0) {
+      console.log("Top Countries");
+      console.log("  " + "-".repeat(40));
+      const maxCountries = 5;
+      for (const c of countries.slice(0, maxCountries)) {
+        console.log(`  ${c.country.padEnd(20)} ${formatNumber(c.requests).padStart(8)} reqs`);
+      }
+      console.log();
+    }
+    if (statusCodes.length > 0) {
+      const grouped = { success: 0, redirect: 0, clientError: 0, serverError: 0 };
+      for (const s of statusCodes) {
+        if (s.statusCode >= 200 && s.statusCode < 300)
+          grouped.success += s.requests;
+        else if (s.statusCode >= 300 && s.statusCode < 400)
+          grouped.redirect += s.requests;
+        else if (s.statusCode >= 400 && s.statusCode < 500)
+          grouped.clientError += s.requests;
+        else if (s.statusCode >= 500)
+          grouped.serverError += s.requests;
+      }
+      console.log("Response Codes");
+      console.log("  " + "-".repeat(40));
+      if (grouped.success > 0)
+        console.log(`  2xx (success):   ${formatNumber(grouped.success).padStart(10)}`);
+      if (grouped.redirect > 0)
+        console.log(`  3xx (redirect):  ${formatNumber(grouped.redirect).padStart(10)}`);
+      if (grouped.clientError > 0)
+        console.log(`  4xx (client err):${formatNumber(grouped.clientError).padStart(10)}`);
+      if (grouped.serverError > 0)
+        console.log(`  5xx (server err):${formatNumber(grouped.serverError).padStart(10)}`);
+      console.log();
+    }
+    console.log("View detailed analytics in the dashboard.");
+  } catch (err) {
+    const message = err instanceof Error ? err.message : "Unknown error";
+    console.error("Failed to get analytics:", message);
+  }
+});
+
 // src/commands/site/index.ts
-var siteCommand = new Command2("site").description("Manage sites").addCommand(siteListCommand).addCommand(siteCreateCommand).addCommand(siteDeleteCommand).addCommand(siteLinkCommand).addCommand(siteUnlinkCommand).addCommand(siteSubdomainCommand);
+var siteCommand = new Command2("site").description("Manage sites").addCommand(siteListCommand).addCommand(siteCreateCommand).addCommand(siteDeleteCommand).addCommand(siteRenameCommand).addCommand(siteLinkCommand).addCommand(siteUnlinkCommand).addCommand(siteSubdomainCommand).addCommand(siteStatsCommand);
 
 // src/commands/domain/add.ts
 var domainAddCommand = new Command2("add").description("Add a custom domain to a site").argument("<domain>", "Domain to add (e.g., www.example.com)").requiredOption("--org <orgSlug>", "Organization slug").requiredOption("--site <siteSlug>", "Site slug").action(async (domain, options) => {
@@ -3425,13 +3889,10 @@ var domainAddCommand = new Command2("add").description("Add a custom domain to a
     return;
   }
   try {
-    const res = await fetch(`${API_URL}/orgs/${options.org}/sites/${options.site}/domains`, {
-      method: "POST",
-      headers: {
-        Authorization: `Bearer ${token}`,
-        "Content-Type": "application/json"
-      },
-      body: JSON.stringify({ domain })
+    const client = getClient(token);
+    const res = await client.orgs[":orgSlug"].sites[":siteSlug"].domains.$post({
+      param: { orgSlug: options.org, siteSlug: options.site },
+      json: { domain }
     });
     if (!res.ok) {
       const error = await res.json();
@@ -3453,7 +3914,7 @@ var domainAddCommand = new Command2("add").description("Add a custom domain to a
     console.log(`   Value: ${data.verification.recordValue}`);
     console.log();
     console.log("After adding the record, run:");
-    console.log(`   zerodeploy domain verify ${data.id} --org ${options.org} --site ${options.site}`);
+    console.log(`   zerodeploy domain verify ${data.domain} --org ${options.org} --site ${options.site}`);
     console.log();
   } catch (err) {
     const message = err instanceof Error ? err.message : "Unknown error";
@@ -3474,6 +3935,16 @@ function formatStatus(status) {
       return status;
   }
 }
+function formatRedirect(mode) {
+  switch (mode) {
+    case "www_to_apex":
+      return "www→apex";
+    case "apex_to_www":
+      return "apex→www";
+    default:
+      return "";
+  }
+}
 var domainListCommand = new Command2("list").description("List custom domains for a site").requiredOption("--org <orgSlug>", "Organization slug").requiredOption("--site <siteSlug>", "Site slug").action(async (options) => {
   const token = loadToken();
   if (!token) {
@@ -3481,16 +3952,15 @@ var domainListCommand = new Command2("list").description("List custom domains fo
     return;
   }
   try {
-    const res = await fetch(`${API_URL}/orgs/${options.org}/sites/${options.site}/domains`, {
-      headers: {
-        Authorization: `Bearer ${token}`
-      }
+    const client = getClient(token);
+    const res = await client.orgs[":orgSlug"].sites[":siteSlug"].domains.$get({
+      param: { orgSlug: options.org, siteSlug: options.site }
     });
     if (!res.ok) {
       const error = await res.json();
       throw new Error(error.error || `API Error ${res.status}`);
     }
-    const domains = await res.json();
+    const { data: domains } = await res.json();
     if (domains.length === 0) {
       console.log("No custom domains configured.");
       console.log();
@@ -3501,7 +3971,9 @@ var domainListCommand = new Command2("list").description("List custom domains fo
     console.log("Custom Domains:");
     console.log();
     for (const d of domains) {
-      console.log(`  ${d.domain.padEnd(30)} ${formatStatus(d.verification_status).padEnd(15)} ${d.id}`);
+      const redirect = formatRedirect(d.redirect_mode);
+      const redirectStr = redirect ? ` [${redirect}]` : "";
+      console.log(`  ${d.domain.padEnd(30)} ${formatStatus(d.verification_status).padEnd(15)}${redirectStr}`);
     }
     console.log();
   } catch (err) {
@@ -3511,24 +3983,38 @@ var domainListCommand = new Command2("list").description("List custom domains fo
 });
 
 // src/commands/domain/verify.ts
-var domainVerifyCommand = new Command2("verify").description("Verify ownership of a custom domain").argument("<domainId>", "Domain ID to verify").requiredOption("--org <orgSlug>", "Organization slug").requiredOption("--site <siteSlug>", "Site slug").action(async (domainId, options) => {
+var domainVerifyCommand = new Command2("verify").description("Verify ownership of a custom domain").argument("<domain>", "Domain to verify (e.g., www.example.com)").requiredOption("--org <orgSlug>", "Organization slug").requiredOption("--site <siteSlug>", "Site slug").action(async (domainName, options) => {
   const token = loadToken();
   if (!token) {
     console.log("Not logged in. Run: zerodeploy login");
     return;
   }
   try {
-    const res = await fetch(`${API_URL}/orgs/${options.org}/sites/${options.site}/domains/${domainId}/verify`, {
-      method: "POST",
-      headers: {
-        Authorization: `Bearer ${token}`,
-        "Content-Type": "application/json"
-      }
+    const client = getClient(token);
+    const listRes = await client.orgs[":orgSlug"].sites[":siteSlug"].domains.$get({
+      param: { orgSlug: options.org, siteSlug: options.site }
+    });
+    if (!listRes.ok) {
+      const error = await listRes.json();
+      throw new Error(error.error || `API Error ${listRes.status}`);
+    }
+    const { data: domains } = await listRes.json();
+    const domain = domains.find((d) => d.domain === domainName);
+    if (!domain) {
+      console.error(`
+❌ Domain not found: ${domainName}`);
+      console.log();
+      console.log("Add it first with:");
+      console.log(`  zerodeploy domain add ${domainName} --org ${options.org} --site ${options.site}`);
+      return;
+    }
+    const res = await client.orgs[":orgSlug"].sites[":siteSlug"].domains[":domainId"].verify.$post({
+      param: { orgSlug: options.org, siteSlug: options.site, domainId: domain.id }
     });
     const data = await res.json();
     if (!res.ok) {
       console.error(`
-❌ Verification failed for domain`);
+❌ Verification failed for ${domainName}`);
       if (data.message) {
         console.log();
         console.log(data.message);
@@ -3536,7 +4022,7 @@ var domainVerifyCommand = new Command2("verify").description("Verify ownership o
       console.log();
       console.log("Tips:");
       console.log("  • DNS changes can take up to 48 hours to propagate");
-      console.log("  • Verify the TXT record is set correctly using: dig TXT _zerodeploy.<domain>");
+      console.log(`  • Verify the TXT record is set correctly using: dig TXT _zerodeploy.${domainName}`);
       console.log("  • Try again in a few minutes");
       return;
     }
@@ -3587,18 +4073,33 @@ var domainVerifyCommand = new Command2("verify").description("Verify ownership o
 });
 
 // src/commands/domain/remove.ts
-var domainRemoveCommand = new Command2("remove").description("Remove a custom domain from a site").argument("<domainId>", "Domain ID to remove").requiredOption("--org <orgSlug>", "Organization slug").requiredOption("--site <siteSlug>", "Site slug").action(async (domainId, options) => {
+var domainRemoveCommand = new Command2("remove").description("Remove a custom domain from a site").argument("<domain>", "Domain to remove (e.g., www.example.com)").requiredOption("--org <orgSlug>", "Organization slug").requiredOption("--site <siteSlug>", "Site slug").action(async (domainName, options) => {
   const token = loadToken();
   if (!token) {
     console.log("Not logged in. Run: zerodeploy login");
     return;
   }
   try {
-    const res = await fetch(`${API_URL}/orgs/${options.org}/sites/${options.site}/domains/${domainId}`, {
-      method: "DELETE",
-      headers: {
-        Authorization: `Bearer ${token}`
-      }
+    const client = getClient(token);
+    const listRes = await client.orgs[":orgSlug"].sites[":siteSlug"].domains.$get({
+      param: { orgSlug: options.org, siteSlug: options.site }
+    });
+    if (!listRes.ok) {
+      const error = await listRes.json();
+      throw new Error(error.error || `API Error ${listRes.status}`);
+    }
+    const { data: domains } = await listRes.json();
+    const domain = domains.find((d) => d.domain === domainName);
+    if (!domain) {
+      console.error(`
+❌ Domain not found: ${domainName}`);
+      console.log();
+      console.log("List domains with:");
+      console.log(`  zerodeploy domain list --org ${options.org} --site ${options.site}`);
+      return;
+    }
+    const res = await client.orgs[":orgSlug"].sites[":siteSlug"].domains[":domainId"].$delete({
+      param: { orgSlug: options.org, siteSlug: options.site, domainId: domain.id }
     });
     if (!res.ok) {
       const error = await res.json();
@@ -3612,12 +4113,304 @@ var domainRemoveCommand = new Command2("remove").description("Remove a custom do
   }
 });
 
+// src/commands/domain/redirect.ts
+function formatRedirectMode(mode) {
+  switch (mode) {
+    case "none":
+      return "No redirect";
+    case "www_to_apex":
+      return "www → apex (e.g., www.example.com → example.com)";
+    case "apex_to_www":
+      return "apex → www (e.g., example.com → www.example.com)";
+    default:
+      return mode;
+  }
+}
+var domainRedirectCommand = new Command2("redirect").description("Set redirect mode for a custom domain").argument("<domain>", "Domain name (e.g., example.com)").requiredOption("--org <orgSlug>", "Organization slug").requiredOption("--site <siteSlug>", "Site slug").requiredOption("--mode <mode>", "Redirect mode: none, www_to_apex, or apex_to_www").action(async (domain, options) => {
+  const token = loadToken();
+  if (!token) {
+    console.log("Not logged in. Run: zerodeploy login");
+    return;
+  }
+  const validModes = ["none", "www_to_apex", "apex_to_www"];
+  if (!validModes.includes(options.mode)) {
+    console.error(`Invalid mode: ${options.mode}`);
+    console.error("Valid modes: none, www_to_apex, apex_to_www");
+    return;
+  }
+  try {
+    const client = getClient(token);
+    const listRes = await client.orgs[":orgSlug"].sites[":siteSlug"].domains.$get({
+      param: { orgSlug: options.org, siteSlug: options.site }
+    });
+    if (!listRes.ok) {
+      const error = await listRes.json();
+      throw new Error(error.error || `API Error ${listRes.status}`);
+    }
+    const { data: domains } = await listRes.json();
+    const targetDomain = domains.find((d) => d.domain === domain.toLowerCase());
+    if (!targetDomain) {
+      console.error(`Domain not found: ${domain}`);
+      console.error(`Run 'zerodeploy domain list --org ${options.org} --site ${options.site}' to see configured domains.`);
+      return;
+    }
+    const res = await client.orgs[":orgSlug"].sites[":siteSlug"].domains[":domainId"].redirect.$patch({
+      param: { orgSlug: options.org, siteSlug: options.site, domainId: targetDomain.id },
+      json: { redirectMode: options.mode }
+    });
+    if (!res.ok) {
+      const error = await res.json();
+      throw new Error(error.error || `API Error ${res.status}`);
+    }
+    const data = await res.json();
+    console.log(`
+✅ Redirect mode updated for ${data.domain}`);
+    console.log(`   Mode: ${formatRedirectMode(data.redirect_mode)}`);
+    console.log();
+  } catch (err) {
+    const message = err instanceof Error ? err.message : "Unknown error";
+    console.error("Failed to update redirect mode:", message);
+  }
+});
+
 // src/commands/domain/index.ts
-var domainCommand = new Command2("domain").description("Manage custom domains").addCommand(domainAddCommand).addCommand(domainListCommand).addCommand(domainVerifyCommand).addCommand(domainRemoveCommand);
+var domainCommand = new Command2("domain").description("Manage custom domains").addCommand(domainAddCommand).addCommand(domainListCommand).addCommand(domainVerifyCommand).addCommand(domainRemoveCommand).addCommand(domainRedirectCommand);
+
+// src/commands/form/list.ts
+var formListCommand = new Command2("list").description("List forms for a site").requiredOption("--org <orgSlug>", "Organization slug").requiredOption("--site <siteSlug>", "Site slug").action(async (options) => {
+  const token = loadToken();
+  if (!token) {
+    console.log("Not logged in. Run: zerodeploy login");
+    return;
+  }
+  try {
+    const client = getClient(token);
+    const res = await client.orgs[":orgSlug"].sites[":siteSlug"].forms.$get({
+      param: { orgSlug: options.org, siteSlug: options.site }
+    });
+    if (!res.ok) {
+      const error = await res.json();
+      throw new Error(error.error || `API Error ${res.status}`);
+    }
+    const { data: forms } = await res.json();
+    if (forms.length === 0) {
+      console.log("No forms found.");
+      console.log();
+      console.log("Forms are created automatically when visitors submit to /_forms/<name>");
+      return;
+    }
+    console.log("Forms:");
+    console.log();
+    console.log("  NAME                          SUBMISSIONS  CREATED");
+    console.log("  " + "-".repeat(60));
+    for (const f of forms) {
+      const created = new Date(f.created_at).toLocaleDateString();
+      console.log(`  ${f.name.padEnd(30)} ${String(f.submission_count).padStart(11)}  ${created}`);
+    }
+    console.log();
+    console.log("Export submissions with:");
+    console.log(`  zerodeploy form export <name> --org ${options.org} --site ${options.site}`);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : "Unknown error";
+    console.error("Failed to list forms:", message);
+  }
+});
+
+// src/commands/form/submissions.ts
+var formSubmissionsCommand = new Command2("submissions").description("View recent form submissions").argument("<name>", "Form name").requiredOption("--org <orgSlug>", "Organization slug").requiredOption("--site <siteSlug>", "Site slug").option("--limit <n>", "Number of submissions to show", "10").option("--offset <n>", "Offset for pagination", "0").action(async (name, options) => {
+  const token = loadToken();
+  if (!token) {
+    console.log("Not logged in. Run: zerodeploy login");
+    return;
+  }
+  try {
+    const client = getClient(token);
+    const res = await client.orgs[":orgSlug"].sites[":siteSlug"].forms[":formName"].submissions.$get({
+      param: { orgSlug: options.org, siteSlug: options.site, formName: name },
+      query: { limit: options.limit, offset: options.offset }
+    });
+    if (!res.ok) {
+      const error = await res.json();
+      throw new Error(error.error || `API Error ${res.status}`);
+    }
+    const data = await res.json();
+    const { form, submissions, total, limit, offset } = data;
+    if (submissions.length === 0) {
+      console.log(`No submissions found for form "${name}".`);
+      return;
+    }
+    console.log(`Form: ${form.name}`);
+    console.log(`Total submissions: ${total}`);
+    if (form.notification_email) {
+      console.log(`Notifications: ${form.notification_email}`);
+    }
+    console.log();
+    if (total > limit) {
+      const start = offset + 1;
+      const end = Math.min(offset + submissions.length, total);
+      console.log(`Showing ${start}-${end} of ${total}`);
+      console.log();
+    }
+    for (const sub of submissions) {
+      const date = new Date(sub.created_at).toLocaleString();
+      const shortId = sub.id.slice(0, 8);
+      console.log(`  ${shortId}  ${date}`);
+      const entries = Object.entries(sub.data);
+      for (const [key, value] of entries) {
+        const displayValue = typeof value === "string" ? value : JSON.stringify(value);
+        const truncated = displayValue.length > 60 ? displayValue.slice(0, 57) + "..." : displayValue;
+        console.log(`    ${key}: ${truncated}`);
+      }
+      const meta = [];
+      if (sub.ip_address)
+        meta.push(`IP: ${sub.ip_address}`);
+      if (sub.referrer)
+        meta.push(`from: ${sub.referrer}`);
+      if (meta.length > 0) {
+        console.log(`    [${meta.join(", ")}]`);
+      }
+      console.log();
+    }
+    if (total > offset + submissions.length) {
+      const nextOffset = offset + parseInt(options.limit);
+      console.log(`View more with: --offset ${nextOffset}`);
+    }
+    console.log("Export all to CSV with:");
+    console.log(`  zerodeploy form export ${name} --org ${options.org} --site ${options.site}`);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : "Unknown error";
+    console.error("Failed to get submissions:", message);
+  }
+});
+
+// src/commands/form/export.ts
+import { writeFile } from "fs/promises";
+import { resolve } from "path";
+var formExportCommand = new Command2("export").description("Export form submissions as CSV").argument("<name>", "Form name").requiredOption("--org <orgSlug>", "Organization slug").requiredOption("--site <siteSlug>", "Site slug").option("-o, --output <file>", "Output file path (default: <name>-submissions.csv)").action(async (name, options) => {
+  const token = loadToken();
+  if (!token) {
+    console.log("Not logged in. Run: zerodeploy login");
+    return;
+  }
+  try {
+    const client = getClient(token);
+    const res = await client.orgs[":orgSlug"].sites[":siteSlug"].forms[":formName"].export.$get({
+      param: { orgSlug: options.org, siteSlug: options.site, formName: name }
+    });
+    if (res.status === 204) {
+      console.log("No submissions to export.");
+      return;
+    }
+    if (!res.ok) {
+      const error = await res.json();
+      throw new Error(error.error || `API Error ${res.status}`);
+    }
+    const csv = await res.text();
+    const outputPath = options.output || `${name}-submissions.csv`;
+    const fullPath = resolve(process.cwd(), outputPath);
+    await writeFile(fullPath, csv, "utf-8");
+    const lineCount = csv.split(`
+`).length - 1;
+    console.log(`Exported ${lineCount} submissions to ${outputPath}`);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : "Unknown error";
+    console.error("Failed to export form:", message);
+  }
+});
+
+// src/commands/form/delete.ts
+import * as readline3 from "readline";
+function prompt3(question) {
+  const rl = readline3.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  return new Promise((resolve2) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve2(answer);
+    });
+  });
+}
+var formDeleteCommand = new Command2("delete").description("Delete a form and all its submissions").argument("<name>", "Form name").requiredOption("--org <orgSlug>", "Organization slug").requiredOption("--site <siteSlug>", "Site slug").option("--force", "Skip confirmation prompt").action(async (name, options) => {
+  const token = loadToken();
+  if (!token) {
+    console.log("Not logged in. Run: zerodeploy login");
+    return;
+  }
+  if (!options.force) {
+    const answer = await prompt3(`Are you sure you want to delete form "${name}" and all its submissions? This cannot be undone. (y/N) `);
+    if (answer.toLowerCase() !== "y") {
+      console.log("Cancelled.");
+      return;
+    }
+  }
+  try {
+    const client = getClient(token);
+    const res = await client.orgs[":orgSlug"].sites[":siteSlug"].forms[":formName"].$delete({
+      param: { orgSlug: options.org, siteSlug: options.site, formName: name }
+    });
+    if (!res.ok) {
+      const error = await res.json();
+      throw new Error(error.error || `API Error ${res.status}`);
+    }
+    const result = await res.json();
+    console.log(`✅ ${result.message}`);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : "Unknown error";
+    console.error("Failed to delete form:", message);
+  }
+});
+
+// src/commands/form/notify.ts
+var formNotifyCommand = new Command2("notify").description("Configure email notifications for form submissions").argument("<name>", "Form name").requiredOption("--org <orgSlug>", "Organization slug").requiredOption("--site <siteSlug>", "Site slug").option("--email <email>", "Email address to receive notifications").option("--disable", "Disable email notifications").action(async (name, options) => {
+  const token = loadToken();
+  if (!token) {
+    console.log("Not logged in. Run: zerodeploy login");
+    return;
+  }
+  if (options.email && options.disable) {
+    console.error("Cannot use both --email and --disable options");
+    return;
+  }
+  if (!options.email && !options.disable) {
+    console.error("Please specify --email <email> or --disable");
+    console.log();
+    console.log("Examples:");
+    console.log(`  zerodeploy form notify ${name} --org ${options.org} --site ${options.site} --email alerts@example.com`);
+    console.log(`  zerodeploy form notify ${name} --org ${options.org} --site ${options.site} --disable`);
+    return;
+  }
+  try {
+    const client = getClient(token);
+    const notificationEmail = options.disable ? null : options.email;
+    const res = await client.orgs[":orgSlug"].sites[":siteSlug"].forms[":formName"].$patch({
+      param: { orgSlug: options.org, siteSlug: options.site, formName: name },
+      json: { notification_email: notificationEmail }
+    });
+    if (!res.ok) {
+      const error = await res.json();
+      throw new Error(error.error || `API Error ${res.status}`);
+    }
+    const { form } = await res.json();
+    if (form.notification_email) {
+      console.log(`Email notifications enabled for form "${name}"`);
+      console.log(`  Notifications will be sent to: ${form.notification_email}`);
+    } else {
+      console.log(`Email notifications disabled for form "${name}"`);
+    }
+  } catch (err) {
+    const message = err instanceof Error ? err.message : "Unknown error";
+    console.error("Failed to update form notifications:", message);
+  }
+});
+
+// src/commands/form/index.ts
+var formCommand = new Command2("form").description("Manage form submissions").addCommand(formListCommand).addCommand(formSubmissionsCommand).addCommand(formExportCommand).addCommand(formDeleteCommand).addCommand(formNotifyCommand);
 
 // src/commands/deploy/index.ts
-import { resolve as resolve3 } from "node:path";
-import { stat as stat2 } from "node:fs/promises";
+import { resolve as resolve4, basename } from "node:path";
+import { stat as stat2, writeFile as writeFile2 } from "node:fs/promises";
 import { spawn } from "node:child_process";
 
 // src/utils/files.ts
@@ -3657,7 +4450,7 @@ async function scanDirectory(rootDir) {
   await scan(rootDir);
   return files;
 }
-function formatBytes(bytes) {
+function formatBytes2(bytes) {
   if (bytes === 0)
     return "0 B";
   const k = 1024;
@@ -3668,7 +4461,7 @@ function formatBytes(bytes) {
 
 // src/utils/framework.ts
 import { readFile as readFile2 } from "node:fs/promises";
-import { resolve } from "node:path";
+import { resolve as resolve2 } from "node:path";
 var FRAMEWORKS = [
   {
     name: "Vite",
@@ -3742,7 +4535,7 @@ function hasDep(pkg, dep) {
 }
 async function detectFramework(cwd) {
   try {
-    const pkgPath = resolve(cwd, "package.json");
+    const pkgPath = resolve2(cwd, "package.json");
     const pkgContent = await readFile2(pkgPath, "utf-8");
     const pkg = JSON.parse(pkgContent);
     for (const framework of FRAMEWORKS) {
@@ -4285,9 +5078,12 @@ function padToBlock(data) {
   padded.set(data);
   return padded;
 }
-async function createTarArchive(files) {
+async function createTarArchive(files, onProgress) {
   const parts = [];
-  for (const file of files) {
+  const total = files.length;
+  for (let i2 = 0;i2 < files.length; i2++) {
+    const file = files[i2];
+    onProgress?.(i2 + 1, total, file.path);
     const content = await readFile3(file.absolutePath);
     const header = createTarHeader(file.path, content.length);
     const paddedContent = padToBlock(new Uint8Array(content));
@@ -4304,8 +5100,8 @@ async function createTarArchive(files) {
   }
   return tar;
 }
-async function createTarGz(files) {
-  const tar = await createTarArchive(files);
+async function createTarGz(files, onProgress) {
+  const tar = await createTarArchive(files, onProgress);
   return gzipSync(tar, { level: 6 });
 }
 function formatCompression(original, compressed) {
@@ -4315,10 +5111,10 @@ function formatCompression(original, compressed) {
 
 // src/utils/project-config.ts
 import { existsSync, readFileSync } from "node:fs";
-import { resolve as resolve2 } from "node:path";
+import { resolve as resolve3 } from "node:path";
 var CONFIG_FILENAME = "zerodeploy.json";
 function loadProjectConfig(cwd = process.cwd()) {
-  const configPath = resolve2(cwd, CONFIG_FILENAME);
+  const configPath = resolve3(cwd, CONFIG_FILENAME);
   if (!existsSync(configPath)) {
     return {};
   }
@@ -4332,7 +5128,137 @@ function loadProjectConfig(cwd = process.cwd()) {
   }
 }
 function getConfigPath(cwd = process.cwd()) {
-  return resolve2(cwd, CONFIG_FILENAME);
+  return resolve3(cwd, CONFIG_FILENAME);
+}
+
+// src/utils/prompt.ts
+import * as readline4 from "node:readline";
+async function confirm(message, defaultValue = true) {
+  const rl = readline4.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  const hint = defaultValue ? "[Y/n]" : "[y/N]";
+  return new Promise((resolve4) => {
+    rl.question(`${message} ${hint} `, (answer) => {
+      rl.close();
+      const normalized = answer.trim().toLowerCase();
+      if (normalized === "") {
+        resolve4(defaultValue);
+      } else if (normalized === "y" || normalized === "yes") {
+        resolve4(true);
+      } else {
+        resolve4(false);
+      }
+    });
+  });
+}
+
+// src/utils/progress.ts
+var SPINNER_FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+var SPINNER_INTERVAL = 80;
+var isTTY = process.stdout.isTTY;
+function clearLine() {
+  if (isTTY) {
+    process.stdout.write("\r\x1B[K");
+  }
+}
+function createSpinner(message) {
+  let frameIndex = 0;
+  let interval = null;
+  let currentMessage = message;
+  function render() {
+    if (!isTTY)
+      return;
+    const frame = SPINNER_FRAMES[frameIndex];
+    clearLine();
+    process.stdout.write(`${frame} ${currentMessage}`);
+    frameIndex = (frameIndex + 1) % SPINNER_FRAMES.length;
+  }
+  return {
+    start() {
+      if (!isTTY) {
+        console.log(currentMessage);
+        return;
+      }
+      render();
+      interval = setInterval(render, SPINNER_INTERVAL);
+    },
+    stop(finalMessage) {
+      if (interval) {
+        clearInterval(interval);
+        interval = null;
+      }
+      clearLine();
+      if (finalMessage) {
+        console.log(finalMessage);
+      }
+    },
+    update(message2) {
+      currentMessage = message2;
+      if (!isTTY) {
+        console.log(message2);
+      }
+    },
+    succeed(message2) {
+      if (interval) {
+        clearInterval(interval);
+        interval = null;
+      }
+      clearLine();
+      console.log(`✓ ${message2}`);
+    },
+    fail(message2) {
+      if (interval) {
+        clearInterval(interval);
+        interval = null;
+      }
+      clearLine();
+      console.log(`✗ ${message2}`);
+    },
+    warn(message2) {
+      if (interval) {
+        clearInterval(interval);
+        interval = null;
+      }
+      clearLine();
+      console.log(`⚠ ${message2}`);
+    }
+  };
+}
+function createProgressBar(options) {
+  const { total, label, width = 20 } = options;
+  let started = false;
+  function render(current, suffix) {
+    const percent = Math.min(current / total, 1);
+    const filled = Math.round(percent * width);
+    const empty = width - filled;
+    const bar = "█".repeat(filled) + "░".repeat(empty);
+    const countStr = `${current}/${total}`;
+    const suffixStr = suffix ? ` ${suffix}` : "";
+    if (isTTY) {
+      clearLine();
+      process.stdout.write(`${label} [${bar}] ${countStr}${suffixStr}`);
+    }
+  }
+  return {
+    update(current, suffix) {
+      if (!isTTY) {
+        if (!started) {
+          console.log(`${label}... ${total} files`);
+          started = true;
+        }
+        return;
+      }
+      render(current, suffix);
+    },
+    done(message) {
+      clearLine();
+      if (message) {
+        console.log(message);
+      }
+    }
+  };
 }
 
 // src/commands/deploy/list.ts
@@ -4352,7 +5278,7 @@ var deployListCommand = new Command2("list").description("List deployments for a
       console.error(`❌ ${error.error}`);
       return;
     }
-    const deployments = await res.json();
+    const { data: deployments } = await res.json();
     const limit = parseInt(options.limit, 10);
     const shown = deployments.slice(0, limit);
     if (shown.length === 0) {
@@ -4363,7 +5289,7 @@ var deployListCommand = new Command2("list").description("List deployments for a
 Deployments for ${options.org}/${siteSlug}:
 `);
     for (const d of shown) {
-      const current = d.isCurrent ? " ← current" : "";
+      const current = d.is_current ? " ← current" : "";
       const status = formatStatus2(d.status);
       const date = new Date(d.created_at).toLocaleString();
       console.log(`  ${d.id.slice(0, 8)}  ${status}  ${date}${current}`);
@@ -4414,22 +5340,113 @@ var deployRollbackCommand = new Command2("rollback").description("Rollback to a
   }
 });
 
+// src/commands/deploy/promote.ts
+var deployPromoteCommand = new Command2("promote").description("Promote a preview deployment to production").argument("<deploymentId>", "Deployment ID (or first 8 chars) to promote").action(async (deploymentId) => {
+  const token = loadToken();
+  if (!token) {
+    console.log("Not logged in. Run: zerodeploy login");
+    return;
+  }
+  try {
+    const client = getClient(token);
+    const res = await client.deployments[":id"].rollback.$post({
+      param: { id: deploymentId }
+    });
+    if (!res.ok) {
+      const error = await res.json();
+      console.error(`Error: ${error.error}`);
+      return;
+    }
+    const result = await res.json();
+    console.log("Deployment promoted to production!");
+    console.log(`   Deployment: ${result.deployment.id}`);
+    console.log(`   URL: ${result.deployment.url}`);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : "Unknown error";
+    console.error("Failed to promote deployment:", message);
+  }
+});
+
 // src/commands/deploy/index.ts
+function slugify(input) {
+  return input.toLowerCase().trim().replace(/[^a-z0-9]+/g, "-").replace(/(^-|-$)+/g, "");
+}
+async function verifyDeployment(url, maxRetries = 3, delayMs = 2000) {
+  for (let attempt = 1;attempt <= maxRetries; attempt++) {
+    try {
+      const controller = new AbortController;
+      const timeout = setTimeout(() => controller.abort(), 1e4);
+      const res = await fetch(url, {
+        method: "GET",
+        signal: controller.signal
+      });
+      clearTimeout(timeout);
+      if (res.ok) {
+        return { success: true, status: res.status };
+      }
+      if (attempt < maxRetries) {
+        await new Promise((resolve5) => setTimeout(resolve5, delayMs));
+        continue;
+      }
+      return { success: false, status: res.status };
+    } catch (err) {
+      if (attempt < maxRetries) {
+        await new Promise((resolve5) => setTimeout(resolve5, delayMs));
+        continue;
+      }
+      const error = err instanceof Error ? err.message : "Unknown error";
+      return { success: false, error };
+    }
+  }
+  return { success: false, error: "Max retries exceeded" };
+}
+async function autoRollback(token, orgSlug, siteSlug, currentDeploymentId) {
+  try {
+    const client = getClient(token);
+    const listRes = await client.orgs[":orgSlug"].sites[":siteSlug"].deployments.$get({
+      param: { orgSlug, siteSlug }
+    });
+    if (!listRes.ok) {
+      return { success: false, error: "Failed to fetch deployments" };
+    }
+    const { data: deployments } = await listRes.json();
+    const previousDeployment = deployments.find((d) => d.id !== currentDeploymentId && d.status === "ready");
+    if (!previousDeployment) {
+      return { success: false, error: "No previous deployment to rollback to" };
+    }
+    const rollbackRes = await client.deployments[":id"].rollback.$post({
+      param: { id: previousDeployment.id }
+    });
+    if (!rollbackRes.ok) {
+      return { success: false, error: "Rollback request failed" };
+    }
+    return { success: true, deploymentId: previousDeployment.id };
+  } catch (err) {
+    const error = err instanceof Error ? err.message : "Unknown error";
+    return { success: false, error };
+  }
+}
 async function runCommand(command, cwd) {
   return new Promise((promiseResolve) => {
-    const [cmd, ...args] = command.split(" ");
+    const parts = command.split(" ");
+    const cmd = parts[0];
+    if (!cmd) {
+      promiseResolve({ success: false, output: "Empty command" });
+      return;
+    }
+    const args = parts.slice(1);
     const proc = spawn(cmd, args, {
       cwd,
       shell: true,
       stdio: ["inherit", "pipe", "pipe"]
     });
     let output = "";
-    proc.stdout?.on("data", (data) => {
+    proc.stdout.on("data", (data) => {
       const text = data.toString();
       output += text;
       process.stdout.write(text);
     });
-    proc.stderr?.on("data", (data) => {
+    proc.stderr.on("data", (data) => {
       const text = data.toString();
       output += text;
       process.stderr.write(text);
@@ -4445,12 +5462,12 @@ async function runCommand(command, cwd) {
 async function findBuildDirectory(cwd) {
   const candidates = ["dist", "build", "out", "public", "."];
   for (const dir of candidates) {
-    const fullPath = resolve3(cwd, dir);
+    const fullPath = resolve4(cwd, dir);
     try {
       const stats = await stat2(fullPath);
       if (stats.isDirectory()) {
         try {
-          await stat2(resolve3(fullPath, "index.html"));
+          await stat2(resolve4(fullPath, "index.html"));
           return fullPath;
         } catch {
           if (dir !== ".")
@@ -4462,42 +5479,126 @@ async function findBuildDirectory(cwd) {
   }
   return null;
 }
-async function uploadArchive(token, uploadUrl, archive) {
-  const res = await fetch(uploadUrl, {
+async function uploadArchive(token, uploadUrl, archive, onRetry) {
+  const res = await fetchWithRetry(uploadUrl, {
     method: "POST",
     headers: {
       "Content-Type": "application/gzip",
       Authorization: `Bearer ${token}`
     },
     body: archive
+  }, {
+    maxRetries: 3,
+    onRetry
   });
   return res.ok;
 }
-var deployCommand = new Command2("deploy").description("Deploy a site").argument("[site]", "Site slug").option("--org <org>", "Organization slug").option("--dir <directory>", "Directory to deploy (default: auto-detect)").option("--build", "Run build command before deploying").option("--no-build", "Skip build step").option("--build-command <command>", "Override build command").option("--install", "Run install command before building").option("--pr <number>", "PR number (for GitHub Actions)").option("--pr-title <title>", "PR title").option("--commit <sha>", "Commit SHA").option("--commit-message <message>", "Commit message").option("--branch <branch>", "Branch name").option("--github-output", "Output deployment info in GitHub Actions format").enablePositionalOptions().addCommand(deployListCommand).addCommand(deployRollbackCommand).action(async (siteSlugArg, options) => {
+var deployCommand = new Command2("deploy").description("Deploy a site").argument("[site]", "Site slug").option("--org <org>", "Organization slug").option("--dir <directory>", "Directory to deploy (default: auto-detect)").option("--build", "Run build command before deploying").option("--no-build", "Skip build step").option("--build-command <command>", "Override build command").option("--install", "Run install command before building").option("--preview", "Deploy without setting as current (preview only)").option("--no-verify", "Skip deployment verification").option("--no-auto-rollback", "Disable automatic rollback on verification failure").option("--pr <number>", "PR number (for GitHub Actions)").option("--pr-title <title>", "PR title").option("--commit <sha>", "Commit SHA").option("--commit-message <message>", "Commit message").option("--branch <branch>", "Branch name").option("--github-output", "Output deployment info in GitHub Actions format").enablePositionalOptions().addCommand(deployListCommand).addCommand(deployRollbackCommand).addCommand(deployPromoteCommand).action(async (siteSlugArg, options) => {
   const cwd = process.cwd();
-  const config = loadProjectConfig(cwd);
-  const siteSlug = siteSlugArg || config.site;
-  const orgSlug = options.org || config.org;
-  const dirOption = options.dir || config.dir;
-  if (!siteSlug) {
-    console.log("Error: Site is required. Provide as argument or in zerodeploy.json");
-    deployCommand.help();
-    return;
-  }
-  if (!orgSlug) {
-    console.log('Error: --org is required (or set "org" in zerodeploy.json)');
-    return;
-  }
   const token = loadToken();
   if (!token) {
-    console.log("Not logged in. Run: zerodeploy login");
+    displayAuthError();
     return;
   }
+  const config = loadProjectConfig(cwd);
+  let siteSlug = siteSlugArg || config.site;
+  let orgSlug = options.org || config.org;
+  const dirOption = options.dir || config.dir;
+  if (!siteSlug || !orgSlug) {
+    const client = getClient(token);
+    const meRes = await client.auth.me.$get();
+    if (!meRes.ok) {
+      console.log("Error: Failed to fetch user info");
+      return;
+    }
+    const userInfo = await meRes.json();
+    if (!orgSlug) {
+      if (!userInfo.personalOrg) {
+        console.log("Error: No personal org found. Please create one with: zerodeploy org create <name>");
+        return;
+      }
+      orgSlug = userInfo.personalOrg.slug;
+    }
+    if (!siteSlug) {
+      const folderName = basename(cwd);
+      const suggestedName = slugify(folderName) || "my-site";
+      console.log("");
+      const shouldCreate = await confirm(`No site configured. Create site "${suggestedName}"?`, true);
+      if (!shouldCreate) {
+        console.log("Deploy cancelled. Create a site first with: zerodeploy site create");
+        return;
+      }
+      console.log("");
+      console.log(`Creating site "${suggestedName}"...`);
+      const createRes = await client.orgs[":orgSlug"].sites.$post({
+        param: { orgSlug },
+        json: { name: suggestedName, subdomain: suggestedName }
+      });
+      if (!createRes.ok) {
+        const error = await createRes.json();
+        console.log(`Error: ${error.error || "Failed to create site"}`);
+        return;
+      }
+      const site = await createRes.json();
+      siteSlug = site.slug;
+      console.log(`Created site: ${site.subdomain}.zerodeploy.app`);
+      const configPath = getConfigPath(cwd);
+      const newConfig = { org: orgSlug, site: siteSlug, dir: dirOption || config.dir };
+      await writeFile2(configPath, JSON.stringify(newConfig, null, 2) + `
+`);
+      console.log(`Saved config to zerodeploy.json`);
+      console.log("");
+    }
+  }
   const framework = await detectFramework(cwd);
   if (framework) {
     console.log(`Detected: ${framework.name}`);
   }
   const shouldBuild = options.build === true;
+  if (shouldBuild || options.install) {
+    const spinner = createSpinner("Checking deployment limits...");
+    spinner.start();
+    try {
+      const client = getClient(token);
+      const sitesRes = await client.orgs[":orgSlug"].sites.$get({
+        param: { orgSlug }
+      });
+      if (!sitesRes.ok) {
+        spinner.fail("Pre-flight check failed");
+        const body = await sitesRes.json();
+        displayError(parseApiError(body));
+        return;
+      }
+      const { data: sites } = await sitesRes.json();
+      const siteExists = sites.some((s) => s.slug === siteSlug);
+      if (!siteExists) {
+        spinner.fail("Pre-flight check failed");
+        displayError({ code: "site_not_found", message: `Site "${siteSlug}" not found in organization "${orgSlug}"` });
+        return;
+      }
+      const usageRes = await client.auth.me.usage.$get();
+      if (usageRes.ok) {
+        const usage = await usageRes.json();
+        const org = usage.orgs.find((o) => o.slug === orgSlug);
+        if (org) {
+          const monthlyUsage = org.deployments_this_month;
+          const monthlyLimit = usage.limits.max_deployments_per_month;
+          const percentUsed = Math.round(monthlyUsage / monthlyLimit * 100);
+          if (percentUsed >= 90) {
+            spinner.warn(`Approaching monthly deployment limit (${monthlyUsage}/${monthlyLimit})`);
+          } else {
+            spinner.succeed("Pre-flight check passed");
+          }
+        } else {
+          spinner.succeed("Pre-flight check passed");
+        }
+      } else {
+        spinner.succeed("Pre-flight check passed");
+      }
+    } catch (err) {
+      spinner.warn("Could not verify limits (will check during deploy)");
+    }
+  }
   if (options.install) {
     const installCmd = config.install || framework?.installCommand || "npm install";
     console.log(`
@@ -4528,7 +5629,7 @@ Error: Build failed`);
   }
   let deployDir;
   if (dirOption) {
-    deployDir = resolve3(cwd, dirOption);
+    deployDir = resolve4(cwd, dirOption);
     try {
       const stats = await stat2(deployDir);
       if (!stats.isDirectory()) {
@@ -4540,7 +5641,7 @@ Error: Build failed`);
       return;
     }
   } else {
-    const detected = framework ? resolve3(cwd, framework.outputDir) : await findBuildDirectory(cwd);
+    const detected = framework ? resolve4(cwd, framework.outputDir) : await findBuildDirectory(cwd);
     if (!detected) {
       console.log("Error: Could not find build directory. Use --dir to specify.");
       return;
@@ -4565,7 +5666,7 @@ Error: Build failed`);
     return;
   }
   const totalSize = files.reduce((sum, f) => sum + f.size, 0);
-  console.log(`Found ${files.length} files (${formatBytes(totalSize)})`);
+  console.log(`Found ${files.length} files (${formatBytes2(totalSize)})`);
   try {
     const client = getClient(token);
     const deployPayload = { siteSlug, orgSlug };
@@ -4589,62 +5690,106 @@ Error: Build failed`);
     });
     if (!createRes.ok) {
       const body = await createRes.json();
-      let message = "Failed to create deployment";
-      if (typeof body.error === "string") {
-        message = body.error;
-      } else if (typeof body.message === "string") {
-        message = body.message;
-      } else if (body.success === false && body.error && typeof body.error === "object") {
-        const zodError = body.error;
-        if (zodError.issues?.[0]) {
-          const issue = zodError.issues[0];
-          const field = issue.path?.join(".") || "";
-          message = field ? `${field}: ${issue.message}` : issue.message;
-        } else if (zodError.message) {
-          try {
-            const issues = JSON.parse(zodError.message);
-            if (issues[0]) {
-              const field = issues[0].path?.join(".") || "";
-              message = field ? `${field}: ${issues[0].message}` : issues[0].message;
-            }
-          } catch {
-            message = zodError.message;
-          }
-        }
-      }
-      console.log(`Error: ${message}`);
+      displayError(parseApiError(body));
       return;
     }
     const deployment = await createRes.json();
     console.log(`Created deployment: ${deployment.id}`);
-    console.log("Creating archive...");
-    const archive = await createTarGz(files);
-    console.log(`  ${formatBytes(totalSize)} -> ${formatBytes(archive.length)} (${formatCompression(totalSize, archive.length)})`);
-    console.log("Uploading...");
+    const progressBar2 = createProgressBar({ total: files.length, label: "Archiving" });
+    const archive = await createTarGz(files, (current, total) => {
+      progressBar2.update(current);
+    });
+    progressBar2.done();
+    console.log(`  ${formatBytes2(totalSize)} -> ${formatBytes2(archive.length)} (${formatCompression(totalSize, archive.length)})`);
+    const uploadSpinner = createSpinner(`Uploading (${formatBytes2(archive.length)})...`);
+    uploadSpinner.start();
     const uploadUrl = deployment.uploadUrl || `${API_URL}/deployments/${deployment.id}/upload`;
-    const uploadSuccess = await uploadArchive(token, uploadUrl, archive);
+    const uploadSuccess = await uploadArchive(token, uploadUrl, archive, (attempt, error, delayMs) => {
+      uploadSpinner.update(`Uploading... ${formatRetryMessage(attempt, 3, error)}, retrying in ${Math.round(delayMs / 1000)}s`);
+    });
     if (!uploadSuccess) {
-      console.log("Error: Failed to upload archive");
+      uploadSpinner.stop("Error: Failed to upload archive");
       return;
     }
-    console.log(`  Uploaded ${formatBytes(archive.length)}`);
-    console.log("Finalizing...");
-    const finalizeRes = await fetch(`${API_URL}/deployments/${deployment.id}/finalize`, {
+    uploadSpinner.stop(`  Uploaded ${formatBytes2(archive.length)}`);
+    const finalizeSpinner = createSpinner("Finalizing...");
+    finalizeSpinner.start();
+    const finalizeRes = await fetchWithRetry(`${API_URL}/deployments/${deployment.id}/finalize`, {
       method: "POST",
       headers: {
         "Content-Type": "application/json",
         Authorization: `Bearer ${token}`
       },
-      body: JSON.stringify({})
+      body: JSON.stringify({ preview: options.preview || false })
+    }, {
+      maxRetries: 3,
+      onRetry: (attempt, error, delayMs) => {
+        finalizeSpinner.update(`Finalizing... ${formatRetryMessage(attempt, 3, error)}, retrying in ${Math.round(delayMs / 1000)}s`);
+      }
     });
     if (!finalizeRes.ok) {
-      console.log("Error: Failed to finalize deployment");
+      finalizeSpinner.stop("Error: Failed to finalize deployment");
       return;
     }
+    finalizeSpinner.stop();
+    const verifyUrl = options.preview ? deployment.previewUrl : deployment.url;
+    let verified = false;
+    if (options.verify !== false) {
+      const verifySpinner = createSpinner("Verifying...");
+      verifySpinner.start();
+      const verification = await verifyDeployment(verifyUrl);
+      verified = verification.success;
+      if (!verified) {
+        verifySpinner.stop();
+        console.log("");
+        console.log("Warning: Could not verify deployment");
+        if (verification.status) {
+          console.log(`  Received status ${verification.status}`);
+        } else if (verification.error) {
+          console.log(`  ${verification.error}`);
+        }
+        if (options.autoRollback !== false && !options.preview) {
+          console.log("");
+          console.log("Auto-rolling back to previous deployment...");
+          const rollback = await autoRollback(token, orgSlug, siteSlug, deployment.id);
+          if (rollback.success) {
+            console.log(`Rolled back to ${rollback.deploymentId?.slice(0, 8)}`);
+            console.log("");
+            console.log("Deployment failed verification and was rolled back.");
+            console.log(`Failed deployment: ${deployment.id.slice(0, 8)}`);
+            console.log(`Check manually: ${verifyUrl}`);
+            return;
+          } else {
+            console.log(`  Could not auto-rollback: ${rollback.error}`);
+            console.log(`  The site may still be propagating. Check manually: ${verifyUrl}`);
+          }
+        } else {
+          console.log(`  The site may still be propagating. Check manually: ${verifyUrl}`);
+        }
+      } else {
+        verifySpinner.stop();
+      }
+    }
     console.log("");
-    console.log("Deployment successful!");
-    console.log(`URL:     ${deployment.url}`);
-    console.log(`Preview: ${deployment.previewUrl}`);
+    if (options.preview) {
+      console.log("Preview deployment created!");
+      if (verified) {
+        console.log(`Preview: ${deployment.previewUrl} (verified)`);
+      } else {
+        console.log(`Preview: ${deployment.previewUrl}`);
+      }
+      console.log("");
+      console.log(`To make this deployment live, run:`);
+      console.log(`  zerodeploy deploy promote ${deployment.id.slice(0, 8)}`);
+    } else {
+      console.log("Deployment successful!");
+      if (verified) {
+        console.log(`URL:     ${deployment.url} (verified)`);
+      } else {
+        console.log(`URL:     ${deployment.url}`);
+      }
+      console.log(`Preview: ${deployment.previewUrl}`);
+    }
     if (options.githubOutput) {
       const githubOutputFile = process.env.GITHUB_OUTPUT;
       if (githubOutputFile) {
@@ -4663,8 +5808,14 @@ Error: Build failed`);
       }
     }
   } catch (err) {
-    const message = err instanceof Error ? err.message : "Unknown error";
-    console.log(`Deploy failed: ${message}`);
+    if (err instanceof Error) {
+      displayNetworkError(err);
+    } else {
+      displayError({
+        code: "unknown_error",
+        message: "Deploy failed: Unknown error"
+      });
+    }
   }
 });
 
@@ -4682,7 +5833,7 @@ var deploymentsListCommand = new Command2("list").description("List deployments
     });
     if (!res.ok)
       throw new Error(`API Error ${res.status}`);
-    const deployments = await res.json();
+    const { data: deployments } = await res.json();
     if (deployments.length === 0) {
       console.log("No deployments found.");
       return;
@@ -4690,7 +5841,7 @@ var deploymentsListCommand = new Command2("list").description("List deployments
     console.log("Deployments:");
     console.log();
     for (const d of deployments) {
-      const current = d.isCurrent ? " (current)" : "";
+      const current = d.is_current ? " (current)" : "";
       const date = new Date(d.created_at).toLocaleString();
       const shortId = d.id.slice(0, 8);
       const commit = d.commit_sha ? ` [${d.commit_sha.slice(0, 7)}]` : "";
@@ -4698,8 +5849,9 @@ var deploymentsListCommand = new Command2("list").description("List deployments
       const message = d.commit_message ? ` - ${(d.commit_message.split(`
 `)[0] ?? "").slice(0, 50)}` : "";
       console.log(`  ${shortId}  ${d.status.padEnd(10)}  ${date}${current}`);
+      console.log(`           ${d.preview_url}`);
       if (commit || message) {
-        console.log(`           ${commit}${branch}${message}`);
+        console.log(`          ${commit}${branch}${message}`);
       }
       console.log();
     }
@@ -4709,8 +5861,109 @@ var deploymentsListCommand = new Command2("list").description("List deployments
   }
 });
 
+// src/commands/deployments/show.ts
+function formatBytes3(bytes) {
+  if (bytes === 0)
+    return "0 B";
+  const k = 1024;
+  const sizes = ["B", "KB", "MB", "GB"];
+  const i2 = Math.floor(Math.log(bytes) / Math.log(k));
+  return parseFloat((bytes / Math.pow(k, i2)).toFixed(1)) + " " + sizes[i2];
+}
+function formatStatus3(status) {
+  switch (status) {
+    case "pending":
+      return "⏳ Pending";
+    case "uploading":
+      return "\uD83D\uDCE4 Uploading";
+    case "processing":
+      return "⚙️  Processing";
+    case "ready":
+      return "✅ Ready";
+    case "failed":
+      return "❌ Failed";
+    default:
+      return status;
+  }
+}
+var deploymentsShowCommand = new Command2("show").description("View deployment details").argument("<id>", "Deployment ID (full or short)").action(async (id) => {
+  const token = loadToken();
+  if (!token) {
+    console.log("Not logged in. Run: zerodeploy login");
+    return;
+  }
+  try {
+    const client = getClient(token);
+    const res = await client.deployments[":id"].$get({
+      param: { id }
+    });
+    if (!res.ok) {
+      if (res.status === 404) {
+        console.error(`Deployment not found: ${id}`);
+        console.log();
+        console.log("Use the full deployment ID or at least 8 characters.");
+        return;
+      }
+      const error = await res.json();
+      throw new Error(error.error || `API Error ${res.status}`);
+    }
+    const d = await res.json();
+    console.log("Deployment Details");
+    console.log("=".repeat(50));
+    console.log();
+    console.log(`ID:        ${d.id}`);
+    console.log(`Status:    ${formatStatus3(d.status)}`);
+    console.log(`Created:   ${new Date(d.created_at).toLocaleString()}`);
+    console.log();
+    console.log("URLs");
+    console.log("-".repeat(50));
+    console.log(`Production:  ${d.url}`);
+    console.log(`Preview:     ${d.preview_url}`);
+    console.log();
+    if (d.commit_sha || d.branch || d.pr_number) {
+      console.log("Git Info");
+      console.log("-".repeat(50));
+      if (d.branch) {
+        console.log(`Branch:    ${d.branch}`);
+      }
+      if (d.commit_sha) {
+        console.log(`Commit:    ${d.commit_sha}`);
+      }
+      if (d.commit_message) {
+        const firstLine = d.commit_message.split(`
+`)[0] ?? "";
+        console.log(`Message:   ${firstLine.slice(0, 60)}${firstLine.length > 60 ? "..." : ""}`);
+      }
+      if (d.pr_number) {
+        console.log(`PR:        #${d.pr_number}${d.pr_title ? ` - ${d.pr_title}` : ""}`);
+      }
+      console.log();
+    }
+    console.log("Files");
+    console.log("-".repeat(50));
+    console.log(`Count:     ${d.file_count.toLocaleString()} files`);
+    console.log(`Size:      ${formatBytes3(d.total_size_bytes)}`);
+    console.log();
+    if (d.status === "failed" && d.error_message) {
+      console.log("Error");
+      console.log("-".repeat(50));
+      console.log(d.error_message);
+      console.log();
+    }
+    if (d.status === "ready") {
+      console.log("Actions");
+      console.log("-".repeat(50));
+      console.log(`Rollback to this deployment:`);
+      console.log(`  zerodeploy rollback <site> --org <org> --to ${d.id.slice(0, 8)}`);
+    }
+  } catch (err) {
+    const message = err instanceof Error ? err.message : "Unknown error";
+    console.error("Failed to get deployment:", message);
+  }
+});
+
 // src/commands/deployments/index.ts
-var deploymentsCommand = new Command2("deployments").description("Manage deployments").addCommand(deploymentsListCommand);
+var deploymentsCommand = new Command2("deployments").description("Manage deployments").addCommand(deploymentsListCommand).addCommand(deploymentsShowCommand);
 
 // src/commands/rollback.ts
 var rollbackCommand = new Command2("rollback").description("Rollback a site to a previous deployment").argument("<site>", "Site slug").requiredOption("--org <org>", "Organization slug").option("--to <deploymentId>", "Deployment ID to rollback to (defaults to previous deployment)").action(async (site, options) => {
@@ -4728,13 +5981,13 @@ var rollbackCommand = new Command2("rollback").description("Rollback a site to a
       });
       if (!listRes.ok)
         throw new Error(`API Error ${listRes.status}`);
-      const deployments = await listRes.json();
+      const { data: deployments } = await listRes.json();
       const readyDeployments = deployments.filter((d) => d.status === "ready");
       if (readyDeployments.length < 2) {
         console.log("No previous deployment to rollback to.");
         return;
       }
-      const currentIndex = readyDeployments.findIndex((d) => d.isCurrent);
+      const currentIndex = readyDeployments.findIndex((d) => d.is_current);
       if (currentIndex === -1 || currentIndex >= readyDeployments.length - 1) {
         deploymentId = readyDeployments[1].id;
       } else {
@@ -4767,13 +6020,10 @@ var tokenCreateCommand = new Command2("create").description("Create a deploy tok
     return;
   }
   try {
-    const res = await fetch(`${API_URL}/orgs/${options.org}/sites/${options.site}/tokens`, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        Authorization: `Bearer ${token}`
-      },
-      body: JSON.stringify({ name })
+    const client = getClient(token);
+    const res = await client.orgs[":orgSlug"].sites[":siteSlug"].tokens.$post({
+      param: { orgSlug: options.org, siteSlug: options.site },
+      json: { name }
     });
     if (!res.ok) {
       const error = await res.json();
@@ -4808,17 +6058,16 @@ var tokenListCommand = new Command2("list").description("List deploy tokens for
     return;
   }
   try {
-    const res = await fetch(`${API_URL}/orgs/${options.org}/sites/${options.site}/tokens`, {
-      headers: {
-        Authorization: `Bearer ${token}`
-      }
+    const client = getClient(token);
+    const res = await client.orgs[":orgSlug"].sites[":siteSlug"].tokens.$get({
+      param: { orgSlug: options.org, siteSlug: options.site }
     });
     if (!res.ok) {
       const error = await res.json();
       console.log(`Error: ${error.error || "Failed to list tokens"}`);
       return;
     }
-    const tokens = await res.json();
+    const { data: tokens } = await res.json();
     if (tokens.length === 0) {
       console.log(`No deploy tokens for ${options.org}/${options.site}`);
       return;
@@ -4845,19 +6094,18 @@ var tokenDeleteCommand = new Command2("delete").description("Delete a deploy tok
     return;
   }
   try {
+    const client = getClient(token);
     let fullTokenId = tokenId;
     if (tokenId.length < 36) {
-      const listRes = await fetch(`${API_URL}/orgs/${options.org}/sites/${options.site}/tokens`, {
-        headers: {
-          Authorization: `Bearer ${token}`
-        }
+      const listRes = await client.orgs[":orgSlug"].sites[":siteSlug"].tokens.$get({
+        param: { orgSlug: options.org, siteSlug: options.site }
       });
       if (!listRes.ok) {
         const error = await listRes.json();
         console.log(`Error: ${error.error || "Failed to find token"}`);
         return;
       }
-      const tokens = await listRes.json();
+      const { data: tokens } = await listRes.json();
       const match = tokens.find((t) => t.id.startsWith(tokenId));
       if (!match) {
         console.log(`Error: No token found starting with "${tokenId}"`);
@@ -4865,11 +6113,8 @@ var tokenDeleteCommand = new Command2("delete").description("Delete a deploy tok
       }
       fullTokenId = match.id;
     }
-    const res = await fetch(`${API_URL}/orgs/${options.org}/sites/${options.site}/tokens/${fullTokenId}`, {
-      method: "DELETE",
-      headers: {
-        Authorization: `Bearer ${token}`
-      }
+    const res = await client.orgs[":orgSlug"].sites[":siteSlug"].tokens[":tokenId"].$delete({
+      param: { orgSlug: options.org, siteSlug: options.site, tokenId: fullTokenId }
     });
     if (!res.ok) {
       const error = await res.json();
@@ -4937,18 +6182,121 @@ var initCommand = new Command2("init").description("Create a zerodeploy.json con
   console.log("  zerodeploy deploy --build   # build + deploy");
 });
 
+// src/commands/account-delete.ts
+import * as readline5 from "readline";
+function prompt4(question) {
+  const rl = readline5.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  return new Promise((resolve5) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve5(answer);
+    });
+  });
+}
+var accountCommand = new Command2("account").description("Manage your ZeroDeploy account").addCommand(new Command2("email").description("Set your email address for notifications").argument("<email>", "Email address").action(async (email) => {
+  const token = loadToken();
+  if (!token) {
+    displayAuthError();
+    return;
+  }
+  const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+  if (!emailRegex.test(email)) {
+    displayError({ code: "validation_error", message: "Invalid email address format" });
+    return;
+  }
+  try {
+    const client = getClient(token);
+    const res = await client.auth.me.$patch({
+      json: { email }
+    });
+    if (!res.ok) {
+      const body = await res.json();
+      displayError(parseApiError(body));
+      return;
+    }
+    console.log(`
+✅ Email updated to: ${email}`);
+    console.log(`   You will now receive deployment notifications at this address.
+`);
+  } catch (err) {
+    if (err instanceof Error) {
+      displayNetworkError(err);
+    } else {
+      displayError({ code: "unknown_error", message: "Failed to update email" });
+    }
+  }
+})).addCommand(new Command2("delete").description("Permanently delete your account and all data").option("--force", "Skip confirmation prompts").action(async (options) => {
+  const token = loadToken();
+  if (!token) {
+    displayAuthError();
+    return;
+  }
+  if (!options.force) {
+    console.log(`
+⚠️  WARNING: This will permanently delete:`);
+    console.log("   - Your account");
+    console.log("   - All organizations you own");
+    console.log("   - All sites and deployments");
+    console.log("   - All custom domains");
+    console.log("   - All deploy tokens");
+    console.log(`
+   This action CANNOT be undone.
+`);
+    const answer1 = await prompt4('Type "delete my account" to confirm: ');
+    if (answer1 !== "delete my account") {
+      console.log("Cancelled.");
+      return;
+    }
+    const answer2 = await prompt4("Are you absolutely sure? (y/N) ");
+    if (answer2.toLowerCase() !== "y") {
+      console.log("Cancelled.");
+      return;
+    }
+  }
+  try {
+    const client = getClient(token);
+    const res = await client.auth.me.$delete();
+    if (!res.ok) {
+      const body = await res.json();
+      displayError(parseApiError(body));
+      return;
+    }
+    const result = await res.json();
+    deleteToken();
+    console.log(`
+✅ Account deleted successfully.`);
+    console.log(`   Deleted: ${result.deleted.orgs} org(s), ${result.deleted.sites} site(s), ${result.deleted.deployments} deployment(s)`);
+    console.log(`
+   Your local authentication token has been removed.`);
+    console.log(`   Thank you for using ZeroDeploy.
+`);
+  } catch (err) {
+    if (err instanceof Error) {
+      displayNetworkError(err);
+    } else {
+      displayError({ code: "unknown_error", message: "Failed to delete account" });
+    }
+  }
+}));
+
 // src/index.ts
 var program3 = new Command;
 program3.name("zerodeploy").description("ZeroDeploy CLI").version("0.1.0").enablePositionalOptions();
 program3.addCommand(loginCommand);
 program3.addCommand(logoutCommand);
 program3.addCommand(whoamiCommand);
+program3.addCommand(usageCommand);
 program3.addCommand(orgCommand);
 program3.addCommand(siteCommand);
 program3.addCommand(domainCommand);
+program3.addCommand(formCommand);
 program3.addCommand(deployCommand);
 program3.addCommand(deploymentsCommand);
 program3.addCommand(rollbackCommand);
 program3.addCommand(tokenCommand);
 program3.addCommand(initCommand);
+program3.addCommand(accountCommand);
 program3.parse(process.argv);