@dropthis/cli 0.10.0 → 0.11.0

package/dist/cli.cjs

@@ -232,12 +232,14 @@ function exitCodeFor(code) {
   if (code === "auth_error") return 3;
   if (code === "local_input_error") return 4;
   if (code === "network_error") return 5;
+  if (code === "verify_pending") return 6;
+  if (code === "verify_timeout") return 7;
   return 1;
 }
 
 // src/program.ts
 var import_commander = require("commander");
-var import_picocolors4 = __toESM(require("picocolors"), 1);
+var import_picocolors5 = __toESM(require("picocolors"), 1);
 
 // src/auth.ts
 async function resolveCredential(input) {
@@ -285,6 +287,9 @@ function success(msg) {
 function error(msg) {
   return `${import_picocolors.default.red(symbols.error)} ${msg}`;
 }
+function warn(msg) {
+  return `${import_picocolors.default.yellow(symbols.warning)} ${msg}`;
+}
 function hint(msg) {
   return `  ${import_picocolors.default.dim(msg)}`;
 }
@@ -305,6 +310,17 @@ function writeResult(deps, link, verb, data) {
     const details = formatDropDetails(data);
     if (details) deps.stdout(`${details}
 `);
+    const warnings = data.warnings;
+    if (Array.isArray(warnings)) {
+      for (const w of warnings) {
+        if (w.code === "slug_suffixed") {
+          deps.stderr(
+            `${hint(`Vanity slug was taken \u2014 served at: ${w.detail ?? "see URL"}`)}
+`
+          );
+        }
+      }
+    }
   } else {
     deps.stdout(`${JSON.stringify({ ok: true, drop: data })}
 `);
@@ -781,19 +797,322 @@ async function runDoctor(_input, deps) {
   const authSource = credential?.source ?? "missing";
   const storageBackend = stored?.storage ?? "none";
   const pairs = [
-    ["Version", "0.10.0"],
+    ["Version", "0.11.0"],
     ["Auth", authSource],
     ["Storage", storageBackend]
   ];
   writeKv(deps, pairs, {
     ok: true,
-    version: "0.10.0",
+    version: "0.11.0",
     auth: { source: authSource },
     storage: { backend: storageBackend }
   });
   return { exitCode: 0 };
 }
 
+// src/commands/domains.ts
+var import_picocolors3 = __toESM(require("picocolors"), 1);
+function formatDnsTable(records) {
+  if (records.length === 0) return "";
+  const rows = [];
+  const colWidths = {
+    type: Math.max(4, ...records.map((r) => r.type.length)),
+    name: Math.max(4, ...records.map((r) => r.name.length)),
+    value: Math.max(5, ...records.map((r) => r.value.length)),
+    status: Math.max(6, ...records.map((r) => r.status.length))
+  };
+  const header = [
+    "Type".padEnd(colWidths.type),
+    "Name".padEnd(colWidths.name),
+    "Value".padEnd(colWidths.value),
+    "Status".padEnd(colWidths.status)
+  ].join("  ");
+  rows.push(import_picocolors3.default.dim(header));
+  rows.push(import_picocolors3.default.dim("\u2500".repeat(header.length)));
+  for (const rec of records) {
+    const statusColor = rec.status === "ok" ? import_picocolors3.default.green(rec.status.padEnd(colWidths.status)) : rec.status === "mismatch" ? import_picocolors3.default.yellow(rec.status.padEnd(colWidths.status)) : import_picocolors3.default.red(rec.status.padEnd(colWidths.status));
+    rows.push(
+      [
+        rec.type.padEnd(colWidths.type),
+        rec.name.padEnd(colWidths.name),
+        rec.value.padEnd(colWidths.value),
+        statusColor
+      ].join("  ")
+    );
+    if (rec.hint) {
+      rows.push(`  ${import_picocolors3.default.dim(rec.hint)}`);
+    }
+    if (rec.observed) {
+      rows.push(`  ${import_picocolors3.default.dim(`Observed: ${rec.observed}`)}`);
+    }
+  }
+  return rows.join("\n");
+}
+function printNextHints(deps, hints) {
+  if (hints.length === 0) return;
+  deps.stdout("\n");
+  for (const h of hints) {
+    deps.stdout(`${hint(h.message)}
+`);
+  }
+}
+function computeSleepMs(records, elapsedMs, timeoutMs) {
+  const maxRetryAfter = records.reduce(
+    (max, r) => Math.max(max, r.retryAfter ?? 0),
+    0
+  );
+  const defaultSeconds = maxRetryAfter > 0 ? maxRetryAfter : 15;
+  const desiredMs = defaultSeconds * 1e3;
+  const remainingMs = timeoutMs - elapsedMs;
+  return Math.min(desiredMs, Math.max(0, remainingMs));
+}
+async function runDomainsConnect(input, deps) {
+  try {
+    await requireCredential({
+      ...deps.apiKey ? { apiKey: deps.apiKey } : {},
+      env: deps.env,
+      store: deps.store
+    });
+  } catch {
+    return writeAuthError(deps);
+  }
+  const result = await deps.client.domains.connect(input);
+  if (result.error) return writeApiError(deps, result.error);
+  const domain = result.data;
+  if (deps.outputMode === "human") {
+    deps.stdout(
+      `${success(`Connected ${domain.hostname} (${domain.mode} mode)`)}
+`
+    );
+    if (domain.dns.length > 0) {
+      deps.stdout("\nDNS records to create at your provider:\n\n");
+      deps.stdout(`${formatDnsTable(domain.dns)}
+`);
+    }
+    printNextHints(deps, domain.next);
+  } else {
+    writeJson(deps, { ok: true, domain });
+  }
+  return { exitCode: 0 };
+}
+async function runDomainsList(_input, deps) {
+  try {
+    await requireCredential({
+      ...deps.apiKey ? { apiKey: deps.apiKey } : {},
+      env: deps.env,
+      store: deps.store
+    });
+  } catch {
+    return writeAuthError(deps);
+  }
+  const result = await deps.client.domains.list();
+  if (result.error) return writeApiError(deps, result.error);
+  const domains = result.data?.domains ?? [];
+  if (deps.outputMode === "human") {
+    if (domains.length === 0) {
+      writeEmpty(deps, "No domains connected yet.", { ok: true, domains: [] });
+    } else {
+      for (const d of domains) {
+        const defaultMark = d.default ? import_picocolors3.default.green(" (default)") : "";
+        const drop = d.dropId ? import_picocolors3.default.dim(` \u2192 ${d.dropId}`) : "";
+        deps.stdout(
+          `  ${d.hostname}${defaultMark}  ${import_picocolors3.default.dim(d.mode)}  ${import_picocolors3.default.dim(d.status)}${drop}
+`
+        );
+      }
+    }
+  } else {
+    writeJson(deps, { ok: true, domains });
+  }
+  return { exitCode: 0 };
+}
+async function runDomainsStatus(idOrHostname, _input, deps) {
+  try {
+    await requireCredential({
+      ...deps.apiKey ? { apiKey: deps.apiKey } : {},
+      env: deps.env,
+      store: deps.store
+    });
+  } catch {
+    return writeAuthError(deps);
+  }
+  const result = await deps.client.domains.get(idOrHostname);
+  if (result.error) return writeApiError(deps, result.error);
+  const domain = result.data;
+  if (deps.outputMode === "human") {
+    deps.stdout(`  ${import_picocolors3.default.dim("Hostname:")}  ${domain.hostname}
+`);
+    deps.stdout(`  ${import_picocolors3.default.dim("Mode:    ")}  ${domain.mode}
+`);
+    deps.stdout(`  ${import_picocolors3.default.dim("Status:  ")}  ${domain.status}
+`);
+    if (domain.failureReason) {
+      deps.stdout(
+        `  ${import_picocolors3.default.dim("Reason:  ")}  ${import_picocolors3.default.red(domain.failureReason)}
+`
+      );
+    }
+    if (domain.dropId) {
+      deps.stdout(`  ${import_picocolors3.default.dim("Drop:    ")}  ${domain.dropId}
+`);
+    }
+    if (domain.verifiedAt) {
+      deps.stdout(`  ${import_picocolors3.default.dim("Verified:")}  ${domain.verifiedAt}
+`);
+    }
+    deps.stdout(`  ${import_picocolors3.default.dim("Created: ")}  ${domain.createdAt}
+`);
+    if (domain.dns.length > 0) {
+      deps.stdout("\nDNS records:\n\n");
+      deps.stdout(`${formatDnsTable(domain.dns)}
+`);
+    }
+    printNextHints(deps, domain.next);
+  } else {
+    writeJson(deps, { ok: true, domain });
+  }
+  return { exitCode: 0 };
+}
+var defaultSleep = (ms) => new Promise((resolve2) => setTimeout(resolve2, ms));
+async function runDomainsVerify(idOrHostname, input, deps, sleep = defaultSleep) {
+  try {
+    await requireCredential({
+      ...deps.apiKey ? { apiKey: deps.apiKey } : {},
+      env: deps.env,
+      store: deps.store
+    });
+  } catch {
+    return writeAuthError(deps);
+  }
+  const timeoutMs = (input.timeout ?? 300) * 1e3;
+  const doVerify = async (elapsedMs) => {
+    const result = await deps.client.domains.verify(idOrHostname);
+    if (result.error) return writeApiError(deps, result.error);
+    const domain = result.data;
+    if (!input.wait) {
+      if (deps.outputMode === "human") {
+        deps.stdout(
+          `${domain.status === "live" ? success(`${idOrHostname} is live`) : warn(`${idOrHostname}: ${domain.status}`)}
+`
+        );
+        if (domain.dns.length > 0) {
+          deps.stdout("\n");
+          deps.stdout(`${formatDnsTable(domain.dns)}
+`);
+        }
+        printNextHints(deps, domain.next);
+      } else {
+        writeJson(deps, { ok: true, domain });
+      }
+      return {
+        exitCode: domain.status === "live" ? 0 : domain.status === "failed" ? 1 : 6
+      };
+    }
+    if (domain.status === "live" || domain.status === "failed") {
+      if (deps.outputMode === "human") {
+        deps.stdout(
+          `${domain.status === "live" ? success(`${idOrHostname} is live`) : warn(`${idOrHostname}: ${domain.status}`)}
+`
+        );
+        if (domain.dns.length > 0) {
+          deps.stdout("\n");
+          deps.stdout(`${formatDnsTable(domain.dns)}
+`);
+        }
+      } else {
+        writeJson(deps, { ok: true, domain });
+      }
+      return { exitCode: domain.status === "live" ? 0 : 1 };
+    }
+    const sleepMs = computeSleepMs(domain.dns, elapsedMs, timeoutMs);
+    const newElapsed = elapsedMs + sleepMs;
+    if (newElapsed >= timeoutMs) {
+      const timeoutSecs = input.timeout ?? 300;
+      const message = `Timed out waiting for ${idOrHostname} to go live after ${timeoutSecs}s`;
+      if (deps.outputMode === "human") {
+        deps.stderr(
+          `  ${import_picocolors3.default.red("Timed out waiting for")} ${idOrHostname} ${import_picocolors3.default.red("to go live")}
+`
+        );
+      } else {
+        deps.stderr(
+          `${JSON.stringify(errorEnvelope("verify_timeout", message))}
+`
+        );
+      }
+      return { exitCode: 7 };
+    }
+    if (deps.outputMode === "human" && domain.dns.length > 0) {
+      deps.stdout(`${formatDnsTable(domain.dns)}
+`);
+    }
+    await sleep(sleepMs);
+    return doVerify(newElapsed);
+  };
+  return doVerify(0);
+}
+async function runDomainsUpdate(idOrHostname, input, deps) {
+  if (input.drop === void 0 && input.setDefault === void 0) {
+    return writeError(
+      deps,
+      "invalid_usage",
+      "Provide at least one option: --drop <dropId> or --default"
+    );
+  }
+  try {
+    await requireCredential({
+      ...deps.apiKey ? { apiKey: deps.apiKey } : {},
+      env: deps.env,
+      store: deps.store
+    });
+  } catch {
+    return writeAuthError(deps);
+  }
+  const updateInput = {};
+  if (input.drop !== void 0) updateInput.dropId = input.drop;
+  if (input.setDefault !== void 0) updateInput.default = input.setDefault;
+  const result = await deps.client.domains.update(idOrHostname, updateInput);
+  if (result.error) return writeApiError(deps, result.error);
+  const domain = result.data;
+  writeHumanOrJson(deps, `${success(`Updated ${domain.hostname}`)}
+`, {
+    ok: true,
+    domain
+  });
+  return { exitCode: 0 };
+}
+async function runDomainsRemove(idOrHostname, _input, deps) {
+  try {
+    await requireCredential({
+      ...deps.apiKey ? { apiKey: deps.apiKey } : {},
+      env: deps.env,
+      store: deps.store
+    });
+  } catch {
+    return writeAuthError(deps);
+  }
+  const result = await deps.client.domains.delete(idOrHostname);
+  if (result.error) return writeApiError(deps, result.error);
+  const deleted = result.data;
+  if (deps.outputMode === "human") {
+    deps.stdout(`${success(`Removed ${deleted.hostname}`)}
+`);
+    if (deleted.warning) {
+      deps.stderr(`${warn(deleted.warning)}
+`);
+    }
+  } else {
+    writeJson(deps, {
+      ok: true,
+      deleted: true,
+      id: deleted.id,
+      hostname: deleted.hostname,
+      warning: deleted.warning
+    });
+  }
+  return { exitCode: 0 };
+}
+
 // src/commands/drops.ts
 var prompts2 = __toESM(require("@clack/prompts"), 1);
 async function runDropsList(input, deps) {
@@ -1131,7 +1450,9 @@ async function parseDropOptions(raw) {
     ...raw.entry ? { entry: raw.entry } : {},
     ...raw.contentType ? { contentType: raw.contentType } : {},
     ...raw.path ? { path: raw.path } : {},
-    ...raw.idempotencyKey ? { idempotencyKey: raw.idempotencyKey } : {}
+    ...raw.idempotencyKey ? { idempotencyKey: raw.idempotencyKey } : {},
+    ...raw.domain ? { domain: raw.domain } : {},
+    ...raw.slug ? { slug: raw.slug } : {}
   };
 }
 function parseJsonObject(value, label) {
@@ -1143,12 +1464,12 @@ function parseJsonObject(value, label) {
 }
 
 // src/spinner.ts
-var import_picocolors3 = __toESM(require("picocolors"), 1);
+var import_picocolors4 = __toESM(require("picocolors"), 1);
 var frames = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
 function createSpinner(message, stderr) {
   let i = 0;
   const timer = setInterval(() => {
-    stderr(`\r\x1B[2K${import_picocolors3.default.cyan(frames[i % frames.length])} ${message}`);
+    stderr(`\r\x1B[2K${import_picocolors4.default.cyan(frames[i % frames.length])} ${message}`);
     i++;
   }, 80);
   return {
@@ -1932,13 +2253,13 @@ function buildProgram(options = {}) {
   });
   program.name("dropthis").description(
     [
-      import_picocolors4.default.dim("Publish anything online and get a URL back."),
+      import_picocolors5.default.dim("Publish anything online and get a URL back."),
       "",
-      `${import_picocolors4.default.bold("Quick start:")}`,
-      `  ${import_picocolors4.default.cyan("dropthis login")}`,
-      `  ${import_picocolors4.default.cyan("dropthis publish ./dist")}`
+      `${import_picocolors5.default.bold("Quick start:")}`,
+      `  ${import_picocolors5.default.cyan("dropthis login")}`,
+      `  ${import_picocolors5.default.cyan("dropthis publish ./dist")}`
     ].join("\n")
-  ).version("0.10.0").configureHelp({
+  ).version("0.11.0").configureHelp({
     subcommandTerm(cmd) {
       const args = cmd.registeredArguments.map((a) => {
         const name = a.name();
@@ -1947,10 +2268,10 @@ function buildProgram(options = {}) {
       }).join(" ");
       return args ? `${cmd.name()} ${args}` : cmd.name();
     },
-    styleTitle: (title) => import_picocolors4.default.bold(title),
-    styleCommandText: (str) => import_picocolors4.default.cyan(str),
-    styleSubcommandText: (str) => import_picocolors4.default.cyan(str),
-    styleOptionText: (str) => import_picocolors4.default.yellow(str)
+    styleTitle: (title) => import_picocolors5.default.bold(title),
+    styleCommandText: (str) => import_picocolors5.default.cyan(str),
+    styleSubcommandText: (str) => import_picocolors5.default.cyan(str),
+    styleOptionText: (str) => import_picocolors5.default.yellow(str)
   });
   program.option("--api-key <key>", "Override API key for this invocation");
   program.option("--api-url <url>", "Override API base URL");
@@ -1968,7 +2289,13 @@ function buildProgram(options = {}) {
   ).option(
     "--metadata <json>",
     `Attach JSON key-value pairs, e.g. '{"source":"ci"}'`
-  ).option("--metadata-file <path>", "Read metadata JSON from a file").option("--path <name>", "Set filename when publishing from stdin").option("--url", "Print only the published URL (no JSON envelope)").option(
+  ).option("--metadata-file <path>", "Read metadata JSON from a file").option("--path <name>", "Set filename when publishing from stdin").option(
+    "--domain <hostname>",
+    "Serve this drop under a connected custom domain (must be live \u2014 see: dropthis domains list). Path-mode: drop lives at https://domain/{slug}/. Dedicated: drop is at the root (409 if occupied). Omit to use the account's default path domain."
+  ).option(
+    "--slug <vanity-slug>",
+    "Vanity slug for path-mode custom domains (1\u201363 lowercase letters/digits/hyphens). Auto-suffixed if taken. Only valid with --domain on a path-mode domain."
+  ).option("--url", "Print only the published URL (no JSON envelope)").option(
     "--dry-run",
     "Show what would be published without publishing (JSON; cannot combine with --url)"
   ).option("--json", "Force JSON output").option(
@@ -2162,6 +2489,76 @@ function buildProgram(options = {}) {
       process.exitCode = result.exitCode;
     }
   );
+  const domains = program.command("domains").description(
+    "Manage custom domains. Loop: connect \u2192 create the CNAME at your DNS provider \u2192 verify --wait \u2192 publish --domain"
+  );
+  domains.command("connect <hostname>").description(
+    "Connect a custom domain. Returns DNS records to create at your provider.\nAfter adding them: dropthis domains verify <hostname> --wait"
+  ).requiredOption(
+    "--mode <mode>",
+    "Mount mode: path (many drops at hostname/{slug}/) or dedicated (one drop at root)"
+  ).option("--json", "Force JSON output").action(
+    async (hostname, commandOptions) => {
+      if (commandOptions.mode !== "path" && commandOptions.mode !== "dedicated") {
+        process.stderr.write(`error: --mode must be "path" or "dedicated"
+`);
+        process.exitCode = 2;
+        return;
+      }
+      const deps = await commandDeps(program, options, store, commandOptions);
+      const result = await runDomainsConnect(
+        { hostname, mode: commandOptions.mode },
+        deps
+      );
+      process.exitCode = result.exitCode;
+    }
+  );
+  domains.command("list").description("List connected custom domains").option("--json", "Force JSON output").action(async (commandOptions) => {
+    const deps = await commandDeps(program, options, store, commandOptions);
+    const result = await runDomainsList(commandOptions, deps);
+    process.exitCode = result.exitCode;
+  });
+  domains.command("status <hostname>").description("Show domain details and DNS record status").option("--json", "Force JSON output").action(async (hostname, commandOptions) => {
+    const deps = await commandDeps(program, options, store, commandOptions);
+    const result = await runDomainsStatus(hostname, commandOptions, deps);
+    process.exitCode = result.exitCode;
+  });
+  domains.command("verify <hostname>").description(
+    "Trigger a DNS verification check. With --wait, polls until live or failed.\nUse after adding the DNS records from: dropthis domains connect"
+  ).option("--wait", "Poll until live (or failed/timeout)").option(
+    "--timeout <secs>",
+    "Max seconds to wait (default: 300)",
+    parseInteger
+  ).option("--json", "Force JSON output").action(
+    async (hostname, commandOptions) => {
+      const deps = await commandDeps(program, options, store, commandOptions);
+      const result = await runDomainsVerify(hostname, commandOptions, deps);
+      process.exitCode = result.exitCode;
+    }
+  );
+  domains.command("update <hostname>").description(
+    "Update a domain \u2014 repoint to a different drop (dedicated mode) or set/clear as account default (path mode). At least one option required."
+  ).option("--drop <dropId>", "Repoint to a different drop (dedicated mode)").option("--default", "Set as account default publish domain (path mode)").option("--json", "Force JSON output").action(
+    async (hostname, commandOptions) => {
+      const deps = await commandDeps(program, options, store, commandOptions);
+      const result = await runDomainsUpdate(
+        hostname,
+        {
+          ...commandOptions.drop !== void 0 ? { drop: commandOptions.drop } : {},
+          ...commandOptions.default !== void 0 ? { setDefault: commandOptions.default } : {}
+        },
+        deps
+      );
+      process.exitCode = result.exitCode;
+    }
+  );
+  domains.command("remove <hostname>").description(
+    "Remove a custom domain. IMPORTANT: also delete the DNS CNAME at your provider to prevent DNS hijacking."
+  ).option("--json", "Force JSON output").action(async (hostname, commandOptions) => {
+    const deps = await commandDeps(program, options, store, commandOptions);
+    const result = await runDomainsRemove(hostname, commandOptions, deps);
+    process.exitCode = result.exitCode;
+  });
   const apiKeys = program.command("api-keys").description("Manage API keys");
   apiKeys.command("create").description("Create an API key").option("--label <label>", "API key label", "CLI").option("--json", "Force JSON output").action(async (commandOptions) => {
     const deps = await commandDeps(program, options, store, commandOptions);
@@ -2400,6 +2797,8 @@ function toDropOptions(options) {
     ...options.contentType ? { contentType: options.contentType } : {},
     ...options.path ? { path: options.path } : {},
     ...options.idempotencyKey ? { idempotencyKey: options.idempotencyKey } : {},
+    ...options.domain ? { domain: options.domain } : {},
+    ...options.slug ? { slug: options.slug } : {},
     ...options.json !== void 0 ? { json: options.json } : {},
     ...options.quiet !== void 0 ? { quiet: options.quiet } : {},
     ...options.url !== void 0 ? { url: options.url } : {},