@dropthis/cli 0.9.3 → 0.11.0

package/node_modules/@dropthis/node/dist/index.cjs

@@ -32,6 +32,7 @@ var index_exports = {};
 __export(index_exports, {
   CursorPage: () => CursorPage,
   DeploymentsResource: () => DeploymentsResource,
+  DomainsResource: () => DomainsResource,
   Dropthis: () => Dropthis,
   PublishInputError: () => PublishInputError,
   UploadsResource: () => UploadsResource,
@@ -245,6 +246,8 @@ function optionsBody(options) {
   if (options.expiresAt !== void 0) {
     body.expiresAt = options.expiresAt instanceof Date ? options.expiresAt.toISOString() : options.expiresAt;
   }
+  if (options.domain !== void 0) body.domain = options.domain;
+  if (options.slug !== void 0) body.slug = options.slug;
   return body;
 }
 function updateContentOptions(options) {
@@ -373,10 +376,49 @@ async function resolveInMemory(input, options = {}) {
   });
   return buildStagedRequest(files, options, input.entry);
 }
+var UPLOAD_CONCURRENCY = 5;
 function errorResult(result) {
   if (!result.error) throw new Error("Expected an error result");
   return { data: null, error: result.error, headers: result.headers };
 }
+async function uploadStagedFiles(transport, jobs) {
+  let nextIndex = 0;
+  let failed = false;
+  const failures = /* @__PURE__ */ new Map();
+  async function worker() {
+    while (!failed) {
+      const index = nextIndex;
+      nextIndex += 1;
+      if (index >= jobs.length) return;
+      const job = jobs[index];
+      if (!job) return;
+      const put = await transport.putSignedUrl(
+        job.target.upload.url,
+        await job.file.getBody(),
+        job.target.upload.headers
+      );
+      if (put.error) {
+        failed = true;
+        failures.set(index, {
+          data: null,
+          error: {
+            ...put.error,
+            message: `Upload failed for ${job.file.path}: ${put.error.message}`
+          },
+          headers: put.headers
+        });
+      }
+    }
+  }
+  const workers = Array.from(
+    { length: Math.min(UPLOAD_CONCURRENCY, jobs.length) },
+    () => worker()
+  );
+  await Promise.all(workers);
+  if (failures.size === 0) return null;
+  const firstIndex = Math.min(...failures.keys());
+  return failures.get(firstIndex) ?? null;
+}
 async function publishStaged(transport, prepared, finalPath, options = {}) {
   const baseKey = options.idempotencyKey ?? `sdk-${crypto.randomUUID()}`;
   const createResult = await transport.request(
@@ -388,6 +430,7 @@ async function publishStaged(transport, prepared, finalPath, options = {}) {
     }
   );
   if (createResult.error) return errorResult(createResult);
+  const jobs = [];
   for (const file of prepared.files) {
     const target = createResult.data.files.find((f) => f.path === file.path);
     if (!target) {
@@ -400,22 +443,18 @@ async function publishStaged(transport, prepared, finalPath, options = {}) {
     if (target.upload.strategy !== "single_put") {
       return createErrorResult(
         "unsupported_upload_strategy",
-        `Unsupported upload strategy "${target.upload.strategy}" for ${file.path}. This SDK uploads via single PUT only.`,
+        `Unexpected upload strategy "${target.upload.strategy}" for ${file.path}. The dropthis upload contract is one signed PUT per file; update @dropthis/node.`,
         null
       );
     }
-    const put = await transport.putSignedUrl(
-      target.upload.url,
-      await file.getBody(),
-      target.upload.headers
-    );
-    if (put.error) return errorResult(put);
+    jobs.push({ file, target });
   }
+  const uploadFailure = await uploadStagedFiles(transport, jobs);
+  if (uploadFailure) return uploadFailure;
   const completeResult = await transport.request(
     "POST",
     `/uploads/${encodeURIComponent(createResult.data.uploadId)}/complete`,
     {
-      body: { files: {} },
       idempotencyKey: `${baseKey}:complete-upload`
     }
   );
@@ -626,6 +665,7 @@ var ApiKeysResource = class {
   create(input) {
     return this.transport.request("POST", "/api-keys", { body: input });
   }
+  /** Revoke an API key. 204 No Content — data is null on success. */
   delete(keyId) {
     return this.transport.request(
       "DELETE",
@@ -652,6 +692,7 @@ var AuthResource = class {
       authenticated: false
     });
   }
+  /** Revoke the current `at_` session token. 204 No Content — data is null on success. */
   logout() {
     return this.transport.request("DELETE", "/auth/session");
   }
@@ -678,6 +719,67 @@ var DeploymentsResource = class {
   }
 };
 
+// src/resources/domains.ts
+var DomainsResource = class {
+  constructor(transport) {
+    this.transport = transport;
+  }
+  transport;
+  /**
+   * Connect a custom domain to the account. Returns the domain in `pending_dns` status with
+   * DNS instructions. Idempotent on (account, hostname) — re-connecting an already-connected
+   * domain returns the existing row. POST /domains.
+   */
+  connect(input) {
+    return this.transport.request("POST", "/domains", { body: input });
+  }
+  /** List all custom domains connected to this account. GET /domains. */
+  list() {
+    return this.transport.request("GET", "/domains");
+  }
+  /** Get a domain by its stable id or hostname. GET /domains/{id_or_hostname}. */
+  get(idOrHostname) {
+    return this.transport.request(
+      "GET",
+      `/domains/${encodeURIComponent(idOrHostname)}`
+    );
+  }
+  /**
+   * Trigger a DNS + Cloudflare verification check. Returns the domain with updated status and
+   * per-record diagnostics. If DNS is still propagating, `dns[].retryAfter` tells you when to
+   * re-call. POST /domains/{id_or_hostname}/verify.
+   */
+  verify(idOrHostname) {
+    return this.transport.request(
+      "POST",
+      `/domains/${encodeURIComponent(idOrHostname)}/verify`
+    );
+  }
+  /**
+   * Update a domain's `dropId` (dedicated mode: repoint to a different drop) or `default`
+   * flag (path mode only: set/clear the account's default publish domain). Mode is immutable
+   * — delete and reconnect to change it. PATCH /domains/{id_or_hostname}.
+   */
+  update(idOrHostname, input) {
+    return this.transport.request(
+      "PATCH",
+      `/domains/${encodeURIComponent(idOrHostname)}`,
+      { body: input }
+    );
+  }
+  /**
+   * Delete a custom domain and remove all its routes. The response includes a dangling-CNAME
+   * warning — remove the DNS record after deleting so another account cannot re-claim the
+   * hostname. DELETE /domains/{id_or_hostname}.
+   */
+  delete(idOrHostname) {
+    return this.transport.request(
+      "DELETE",
+      `/domains/${encodeURIComponent(idOrHostname)}`
+    );
+  }
+};
+
 // src/pagination.ts
 var CursorPage = class {
   object = "list";
@@ -713,12 +815,29 @@ var CursorPage = class {
 
 // src/resources/drops.ts
 var DropsResource = class {
-  constructor(transport, resolve) {
+  constructor(transport, resolveInput2) {
     this.transport = transport;
-    this.resolve = resolve;
+    this.resolveInput = resolveInput2;
   }
   transport;
-  resolve;
+  resolveInput;
+  parentHosts;
+  /**
+   * Hostnames the SDK can attribute to dropthis for slug parsing: the canonical
+   * viewer domain plus the configured baseUrl's host (covers staging/self-hosted
+   * setups where drops are served under the API's own domain).
+   */
+  allowedParentHosts() {
+    if (!this.parentHosts) {
+      const hosts = /* @__PURE__ */ new Set([CANONICAL_VIEWER_HOST]);
+      try {
+        hosts.add(new URL(this.transport.baseUrl).hostname);
+      } catch {
+      }
+      this.parentHosts = hosts;
+    }
+    return this.parentHosts;
+  }
   /**
    * Publish content to a NEW permanent public URL; returns the created drop (with its `drop_…` id).
    * Use to publish / share / post / put online / make public a report, dashboard, site, or file.
@@ -729,7 +848,7 @@ var DropsResource = class {
   async publish(input, options = {}) {
     let prepared;
     try {
-      prepared = await this.resolve(input, options);
+      prepared = await this.resolveInput(input, options);
     } catch (e) {
       return toErrorResult(e);
     }
@@ -746,7 +865,7 @@ var DropsResource = class {
     const opts = updateContentOptions(options);
     let prepared;
     try {
-      prepared = await this.resolve(input, opts);
+      prepared = await this.resolveInput(input, opts);
     } catch (e) {
       return toErrorResult(e);
     }
@@ -774,10 +893,67 @@ var DropsResource = class {
       `/drops/${encodeURIComponent(dropId)}`
     );
   }
+  /**
+   * Resolve a drop URL (or bare slug) back to the drop — the way to recover a lost
+   * `drop_…` id. The slug is parsed client-side from the first hostname label of a
+   * dropthis-attributable hostname (`https://<slug>.dropthis.app/…`, or `<slug>.` +
+   * the configured baseUrl's host), then matched owner-scoped via GET /drops?slug=.
+   * Returns the drop, or `data: null` when no drop of yours has that slug.
+   * Custom-domain URLs are rejected client-side with `invalid_drop_url` — they are
+   * not resolvable yet.
+   */
+  async resolve(urlOrSlug) {
+    const slug = parseSlug(urlOrSlug, this.allowedParentHosts());
+    if (slug === null) {
+      return createErrorResult(
+        "invalid_drop_url",
+        `Could not resolve a drop slug from "${urlOrSlug}". Pass a canonical drop URL like https://<slug>.dropthis.app/ or the bare slug \u2014 custom-domain URLs cannot be resolved yet.`,
+        null
+      );
+    }
+    const result = await this.transport.request("GET", "/drops", { params: { slug } });
+    if (result.error)
+      return { data: null, error: result.error, headers: result.headers };
+    return {
+      data: result.data.drops[0] ?? null,
+      error: null,
+      headers: result.headers
+    };
+  }
+  async getContent(dropId, options = {}) {
+    const base = options.deploymentId !== void 0 ? `/drops/${encodeURIComponent(dropId)}/deployments/${encodeURIComponent(options.deploymentId)}/content` : `/drops/${encodeURIComponent(dropId)}/content`;
+    if (options.path === void 0)
+      return this.transport.request("GET", base);
+    const path = options.path;
+    const result = await this.transport.requestBytes(base, {
+      params: { path }
+    });
+    if (result.error)
+      return { data: null, error: result.error, headers: result.headers };
+    const { bytes, contentType } = result.data;
+    return {
+      data: {
+        path,
+        contentType,
+        bytes,
+        text: () => new TextDecoder().decode(bytes)
+      },
+      error: null,
+      headers: result.headers
+    };
+  }
   /**
    * Change an EXISTING drop's settings — title, visibility, password, noindex, expiry,
-   * metadata — by its `drop_…` id. Does not touch content; replace that with {@link updateContent}.
-   * Idempotent. PATCH /drops/{id}.
+   * metadata, domain, or slug — by its `drop_…` id. Does not touch content; replace that
+   * with {@link updateContent}. Idempotent. PATCH /drops/{id}.
+   *
+   * **`domain`** — move the drop to a different custom domain (must be live). Pass `null` to
+   * move the drop back to the shared pool (unmount from its current domain).
+   *
+   * **`slug`** — rename the vanity slug on a path-mode custom domain. Only valid when the drop
+   * lives on a path-mode domain. Unlike {@link publish} (which auto-suffixes taken slugs),
+   * `updateSettings` returns 409 on a slug conflict and never auto-suffixes — your code must
+   * catch 409 and retry with a different slug. Passing `slug` on the shared pool returns 422.
    */
   updateSettings(dropId, options = {}) {
     const requestOptions = {
@@ -801,12 +977,33 @@ var DropsResource = class {
     );
   }
 };
+var CANONICAL_VIEWER_HOST = "dropthis.app";
+function parseSlug(input, allowedParents) {
+  const value = input.trim();
+  if (!value) return null;
+  if (!/[./]/.test(value)) return value;
+  const withScheme = /^[a-z][a-z0-9+.-]*:\/\//i.test(value) ? value : `https://${value}`;
+  let hostname;
+  try {
+    hostname = new URL(withScheme).hostname;
+  } catch {
+    return null;
+  }
+  hostname = hostname.replace(/\.$/, "");
+  const dot = hostname.indexOf(".");
+  if (dot <= 0) return null;
+  const slug = hostname.slice(0, dot);
+  const parent = hostname.slice(dot + 1);
+  return allowedParents.has(parent) ? slug : null;
+}
 var SETTINGS = [
   "title",
   "visibility",
   "password",
   "noindex",
-  "expiresAt"
+  "expiresAt",
+  "domain",
+  "slug"
 ];
 function updateBody(options) {
   const out = {};
@@ -836,8 +1033,12 @@ var UploadsResource = class {
       `/uploads/${encodeURIComponent(uploadId)}`
     );
   }
-  complete(uploadId, body, options = {}) {
-    const requestOptions = { body };
+  /**
+   * Verify staged objects and mark the session complete. Takes no request body —
+   * the server verifies the uploaded bytes against the staged manifest.
+   */
+  complete(uploadId, options = {}) {
+    const requestOptions = {};
     if (options.idempotencyKey)
       requestOptions.idempotencyKey = options.idempotencyKey;
     return this.transport.request(
@@ -889,7 +1090,7 @@ function toSnakeCase(value) {
 
 // src/transport.ts
 var DEFAULT_BASE_URL = "https://api.dropthis.app";
-var SDK_VERSION = "0.8.0";
+var SDK_VERSION = "0.10.0";
 var Transport = class {
   apiKey;
   baseUrl;
@@ -949,6 +1150,63 @@ var Transport = class {
       clearTimeout(timeout);
     }
   }
+  /**
+   * Authenticated GET that returns the raw response bytes untouched (no JSON parsing,
+   * no case conversion). Error responses are still parsed as problem+json. Used for
+   * content read-back (`drops.getContent` with a file path).
+   */
+  async requestBytes(path, options = {}) {
+    if (!this.apiKey) {
+      return createErrorResult(
+        "missing_api_key",
+        "No API key provided. Pass apiKey or set DROPTHIS_API_KEY.",
+        null
+      );
+    }
+    const headers = {
+      "user-agent": `dropthis-node/${SDK_VERSION}`,
+      authorization: `Bearer ${this.apiKey}`
+    };
+    const url = new URL(`${this.baseUrl}${path}`);
+    for (const [key, value] of Object.entries(options.params ?? {})) {
+      if (value !== void 0 && value !== null)
+        url.searchParams.set(key, String(value));
+    }
+    const controller = new AbortController();
+    const timeout = setTimeout(
+      () => controller.abort(),
+      options.timeoutMs ?? this.timeoutMs
+    );
+    try {
+      const response = await this.fetchImpl(url.toString(), {
+        method: "GET",
+        headers,
+        signal: controller.signal
+      });
+      const responseHeaders = headersToObject(response.headers);
+      if (!response.ok) {
+        const text = await response.text();
+        return problemResult(response, text, responseHeaders);
+      }
+      return {
+        data: {
+          bytes: new Uint8Array(await response.arrayBuffer()),
+          contentType: response.headers.get("content-type") ?? responseHeaders["content-type"] ?? null
+        },
+        error: null,
+        headers: responseHeaders
+      };
+    } catch (error) {
+      const message = error instanceof Error && error.name === "AbortError" ? "Request timed out" : error instanceof Error ? error.message : "Network error";
+      return createErrorResult(
+        error instanceof Error && error.name === "AbortError" ? "timeout" : "network_error",
+        message,
+        null
+      );
+    } finally {
+      clearTimeout(timeout);
+    }
+  }
   async request(method, path, options = {}) {
     const authenticated = options.authenticated ?? true;
     if (authenticated && !this.apiKey) {
@@ -995,31 +1253,10 @@ var Transport = class {
       const response = await this.fetchImpl(url.toString(), request);
       const responseHeaders = headersToObject(response.headers);
       const text = await response.text();
-      const parsed = parseJson(text);
-      if (!response.ok) {
-        const body = parsed && typeof parsed === "object" ? parsed : {};
-        const message = stringValue(body.detail) ?? stringValue(body.title) ?? response.statusText;
-        const code = stringValue(body.code) ?? stringValue(body.error_code) ?? `http_${response.status}`;
-        const currentRevision = numberValue(body.current_revision);
-        const type = stringValue(body.type);
-        const title = stringValue(body.title);
-        const instance = stringValue(body.instance);
-        return createErrorResult(code, message, response.status, {
-          body,
-          ...type !== null ? { type } : {},
-          ...title !== null ? { title } : {},
-          ...instance !== null ? { instance } : {},
-          detail: stringValue(body.detail),
-          param: stringValue(body.param),
-          ...currentRevision !== void 0 ? { currentRevision } : {},
-          requestId: stringValue(body.request_id) ?? responseHeaders["x-request-id"] ?? null,
-          suggestion: stringValue(body.suggestion),
-          retryable: booleanValue(body.retryable),
-          headers: responseHeaders
-        });
-      }
+      if (!response.ok)
+        return problemResult(response, text, responseHeaders);
       return {
-        data: toCamelCase(parsed),
+        data: toCamelCase(parseJson(text)),
         error: null,
         headers: responseHeaders
       };
@@ -1035,6 +1272,29 @@ var Transport = class {
     }
   }
 };
+function problemResult(response, text, responseHeaders) {
+  const parsed = parseJson(text);
+  const body = parsed && typeof parsed === "object" ? parsed : {};
+  const message = stringValue(body.detail) ?? stringValue(body.title) ?? response.statusText;
+  const code = stringValue(body.code) ?? stringValue(body.error_code) ?? `http_${response.status}`;
+  const currentRevision = numberValue(body.current_revision);
+  const type = stringValue(body.type);
+  const title = stringValue(body.title);
+  const instance = stringValue(body.instance);
+  return createErrorResult(code, message, response.status, {
+    body,
+    ...type !== null ? { type } : {},
+    ...title !== null ? { title } : {},
+    ...instance !== null ? { instance } : {},
+    detail: stringValue(body.detail),
+    param: stringValue(body.param),
+    ...currentRevision !== void 0 ? { currentRevision } : {},
+    requestId: stringValue(body.request_id) ?? responseHeaders["x-request-id"] ?? null,
+    suggestion: stringValue(body.suggestion),
+    retryable: booleanValue(body.retryable),
+    headers: responseHeaders
+  });
+}
 function headersToObject(headers) {
   const result = {};
   headers.forEach((value, key) => {
@@ -1069,6 +1329,7 @@ var Dropthis = class {
   dropsResource;
   deploymentsResource;
   uploadsResource;
+  domainsResource;
   constructor(options = {}) {
     this.transport = new Transport(options);
   }
@@ -1102,6 +1363,11 @@ var Dropthis = class {
       this.uploadsResource = new UploadsResource(this.transport);
     return this.uploadsResource;
   }
+  get domains() {
+    if (!this.domainsResource)
+      this.domainsResource = new DomainsResource(this.transport);
+    return this.domainsResource;
+  }
   async prepare(input, options = {}) {
     return resolveInput(input, options);
   }
@@ -1110,6 +1376,7 @@ var Dropthis = class {
 0 && (module.exports = {
   CursorPage,
   DeploymentsResource,
+  DomainsResource,
   Dropthis,
   PublishInputError,
   UploadsResource,