@dropthis/cli 0.9.3 → 0.11.0

package/dist/cli.cjs

@@ -135,10 +135,10 @@ function readlineQuestion(question) {
     input: process.stdin,
     output: process.stderr
   });
-  return new Promise((resolve) => {
+  return new Promise((resolve2) => {
     rl.question(question, (answer) => {
       rl.close();
-      resolve(answer);
+      resolve2(answer);
     });
   });
 }
@@ -207,7 +207,7 @@ function nextActionForApiError(error2) {
   const uploadNextAction = error2.code ? UPLOAD_NEXT_ACTIONS[error2.code] : void 0;
   if (uploadNextAction) return uploadNextAction;
   if (error2.code === "revision_conflict") {
-    return "Fetch the drop, merge your changes, and retry with the current revision.";
+    return "Re-read the drop with dropthis get <drop-id>, merge your changes, and retry with --if-revision set to the current revision.";
   }
   if (error2.statusCode === 404 || error2.code === "not_found") {
     return "Check the drop id or slug and retry; list your drops with dropthis list.";
@@ -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 })}
 `);
@@ -371,6 +387,11 @@ function writeApiError(deps, details) {
     const nextAction = nextActionForApiError(details);
     if (nextAction) deps.stderr(`${hint(nextAction)}
 `);
+    if (details.currentRevision !== void 0)
+      deps.stderr(
+        `${hint(`Current revision: ${details.currentRevision} \u2014 retry with --if-revision ${details.currentRevision}`)}
+`
+      );
     if (details.requestId)
       deps.stderr(`${import_picocolors2.default.dim(`Request ID: ${details.requestId}`)}
 `);
@@ -605,6 +626,13 @@ var COMMAND_ANNOTATIONS = {
     auth: "required",
     examples: ["dropthis update-settings drop_abc --title 'Launch' --json"]
   },
+  pull: {
+    auth: "required",
+    examples: [
+      "dropthis pull drop_abc -o ./site",
+      "dropthis pull https://abc123.dropthis.app"
+    ]
+  },
   get: {
     auth: "required",
     examples: ["dropthis get drop_abc --json"]
@@ -769,19 +797,322 @@ async function runDoctor(_input, deps) {
   const authSource = credential?.source ?? "missing";
   const storageBackend = stored?.storage ?? "none";
   const pairs = [
-    ["Version", "0.9.3"],
+    ["Version", "0.11.0"],
     ["Auth", authSource],
     ["Storage", storageBackend]
   ];
   writeKv(deps, pairs, {
     ok: true,
-    version: "0.9.3",
+    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) {
@@ -1119,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) {
@@ -1131,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 {
@@ -1274,6 +1607,110 @@ async function handlePublishDryRun(input, raw, deps, client) {
   }
 }
 
+// src/commands/pull.ts
+var import_promises2 = require("fs/promises");
+var import_node_path = require("path");
+async function runPull(target, input, deps) {
+  try {
+    await requireCredential({
+      ...deps.apiKey ? { apiKey: deps.apiKey } : {},
+      env: deps.env,
+      store: deps.store
+    });
+  } catch {
+    return writeAuthError(deps);
+  }
+  let dropId;
+  let defaultDirName;
+  if (target.startsWith("drop_")) {
+    dropId = target;
+    defaultDirName = target;
+  } else {
+    const resolved = await deps.client.drops.resolve(target);
+    if (resolved.error) return writeApiError(deps, resolved.error);
+    if (resolved.data === null) {
+      return writeApiError(deps, {
+        code: "not_found",
+        message: `No drop matching "${target}" found in your account.`,
+        suggestion: "It may belong to another account or have been deleted. Run dropthis list to see your drops, or pass the full drop_\u2026 id."
+      });
+    }
+    dropId = resolved.data.id;
+    defaultDirName = resolved.data.slug || resolved.data.id;
+  }
+  const spin = shouldSpin(deps.outputMode) ? createSpinner("Pulling content\u2026", deps.stderr) : void 0;
+  const manifestResult = await deps.client.drops.getContent(dropId);
+  if (manifestResult.error) {
+    spin?.fail();
+    return writeApiError(deps, manifestResult.error);
+  }
+  const manifest = manifestResult.data;
+  const outDir = (0, import_node_path.resolve)(
+    deps.cwd ?? process.cwd(),
+    input.output ?? defaultDirName
+  );
+  let destinations;
+  try {
+    destinations = manifest.files.map((file) => ({
+      path: file.path,
+      dest: safeDestination(outDir, file.path)
+    }));
+  } catch (error2) {
+    spin?.fail();
+    const message = error2 instanceof Error ? error2.message : "Invalid manifest path.";
+    return writeError(deps, "local_input_error", message);
+  }
+  try {
+    await (0, import_promises2.mkdir)(outDir, { recursive: true });
+    for (const { path, dest } of destinations) {
+      const fileResult = await deps.client.drops.getContent(dropId, { path });
+      if (fileResult.error) {
+        spin?.fail();
+        return writeApiError(deps, {
+          ...fileResult.error,
+          message: `${path}: ${fileResult.error.message}`
+        });
+      }
+      const file = fileResult.data;
+      await (0, import_promises2.mkdir)((0, import_node_path.dirname)(dest), { recursive: true });
+      await (0, import_promises2.writeFile)(dest, file.bytes);
+    }
+  } catch (error2) {
+    spin?.fail();
+    const message = error2 instanceof Error ? error2.message : "Failed to write files.";
+    return writeError(deps, "local_input_error", message);
+  }
+  spin?.stop();
+  const count = manifest.files.length;
+  writeHumanOrJson(
+    deps,
+    success(`Pulled ${count} ${count === 1 ? "file" : "files"} to ${outDir}`),
+    {
+      ok: true,
+      pulled: {
+        dropId: manifest.dropId,
+        deploymentId: manifest.deploymentId,
+        revision: manifest.revision,
+        ...manifest.entry !== void 0 ? { entry: manifest.entry } : {},
+        dir: outDir,
+        files: manifest.files
+      }
+    }
+  );
+  return { exitCode: 0 };
+}
+function safeDestination(outDir, filePath) {
+  if (!filePath || (0, import_node_path.isAbsolute)(filePath)) {
+    throw new Error(`Unsafe file path in content manifest: "${filePath}"`);
+  }
+  const dest = (0, import_node_path.join)(outDir, filePath);
+  const rel = (0, import_node_path.relative)(outDir, dest);
+  if (rel.startsWith("..") || (0, import_node_path.isAbsolute)(rel)) {
+    throw new Error(`Unsafe file path in content manifest: "${filePath}"`);
+  }
+  return dest;
+}
+
 // src/commands/update-content.ts
 var NO_CONTENT_MESSAGE = "update-content requires content. Provide a file, folder, URL, or text to ship a new deployment.";
 var NO_CONTENT_NEXT_ACTION = "Pass an input, e.g. dropthis update-content <dropId> ./dist. To change title, visibility, password, expiry, or metadata, use dropthis update-settings <dropId> instead.";
@@ -1691,9 +2128,9 @@ function createContext(input) {
 }
 
 // src/storage.ts
-var import_promises2 = require("fs/promises");
+var import_promises3 = require("fs/promises");
 var import_node_os = require("os");
-var import_node_path = require("path");
+var import_node_path2 = require("path");
 var import_keyring = require("@napi-rs/keyring");
 var MemoryCredentialStore = class {
   credential = null;
@@ -1725,7 +2162,7 @@ var InsecureFileCredentialStore = class {
     });
   }
   async clear() {
-    await (0, import_promises2.rm)(this.filePath, { force: true });
+    await (0, import_promises3.rm)(this.filePath, { force: true });
   }
 };
 var KeyringCredentialStore = class {
@@ -1752,7 +2189,7 @@ var KeyringCredentialStore = class {
   }
   async clear() {
     await this.keyring.deletePassword();
-    await (0, import_promises2.rm)(this.filePath, { force: true });
+    await (0, import_promises3.rm)(this.filePath, { force: true });
   }
 };
 function createCredentialStore(options = {}) {
@@ -1770,14 +2207,14 @@ function defaultKeyringAdapter() {
   };
 }
 function credentialPath(configDir) {
-  return (0, import_node_path.join)(
-    configDir ?? (0, import_node_path.join)((0, import_node_os.homedir)(), ".config", "dropthis"),
+  return (0, import_node_path2.join)(
+    configDir ?? (0, import_node_path2.join)((0, import_node_os.homedir)(), ".config", "dropthis"),
     "credentials.json"
   );
 }
 async function readJsonFile(path) {
   try {
-    return JSON.parse(await (0, import_promises2.readFile)(path, "utf8"));
+    return JSON.parse(await (0, import_promises3.readFile)(path, "utf8"));
   } catch (error2) {
     if (error2 && typeof error2 === "object" && "code" in error2 && error2.code === "ENOENT") {
       return null;
@@ -1786,14 +2223,14 @@ async function readJsonFile(path) {
   }
 }
 async function writeCredentialFile(path, credential) {
-  await (0, import_promises2.mkdir)((0, import_node_path.dirname)(path), { recursive: true });
+  await (0, import_promises3.mkdir)((0, import_node_path2.dirname)(path), { recursive: true });
   const tmpPath = `${path}.${process.pid}.tmp`;
-  await (0, import_promises2.writeFile)(tmpPath, `${JSON.stringify(credential, null, 2)}
+  await (0, import_promises3.writeFile)(tmpPath, `${JSON.stringify(credential, null, 2)}
 `, {
     mode: 384
   });
-  await (0, import_promises2.chmod)(tmpPath, 384);
-  await (0, import_promises2.rename)(tmpPath, path);
+  await (0, import_promises3.chmod)(tmpPath, 384);
+  await (0, import_promises3.rename)(tmpPath, path);
 }
 
 // src/program.ts
@@ -1816,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.9.3").configureHelp({
+  ).version("0.11.0").configureHelp({
     subcommandTerm(cmd) {
       const args = cmd.registeredArguments.map((a) => {
         const name = a.name();
@@ -1831,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");
@@ -1852,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(
@@ -1984,6 +2427,20 @@ function buildProgram(options = {}) {
       process.exitCode = result.exitCode;
     }
   );
+  program.command("pull <target>").description(
+    "Download a drop's files into a local directory (accepts the drop_\u2026 id, the drop URL, or its slug).\nFetches the current deployment's file manifest and writes every file. Pull, edit, then update-content to ship the changes back to the same URL \u2014 also the rollback path."
+  ).option("-o, --output <dir>", "Output directory (default: ./<slug-or-id>)").option("--json", "Force JSON output").action(
+    async (target, commandOptions) => {
+      const deps = await commandDeps(
+        program,
+        options,
+        store,
+        commandOptions
+      );
+      const result = await runPull(target, commandOptions, deps);
+      process.exitCode = result.exitCode;
+    }
+  );
   program.command("get <dropId>").description("Show drop details (pass the full drop_\u2026 id)").option("--json", "Force JSON output").action(async (dropId, commandOptions) => {
     const deps = await commandDeps(program, options, store, commandOptions);
     const result = await runDropsGet(dropId, commandOptions, deps);
@@ -2032,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);
@@ -2270,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 } : {},