@dropthis/cli 0.9.3 → 0.10.0

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

@@ -333,10 +333,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(
@@ -348,6 +387,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) {
@@ -360,22 +400,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`
     }
   );
@@ -434,6 +470,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",
@@ -498,12 +535,29 @@ var CursorPage = class {
 
 // src/resources/drops.ts
 var DropsResource = class {
-  constructor(transport, resolve) {
+  constructor(transport, resolveInput) {
     this.transport = transport;
-    this.resolve = resolve;
+    this.resolveInput = resolveInput;
   }
   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.
@@ -514,7 +568,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);
     }
@@ -531,7 +585,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);
     }
@@ -559,6 +613,55 @@ 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}.
@@ -586,6 +689,25 @@ 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",
@@ -638,7 +760,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;
@@ -698,6 +820,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) {
@@ -744,31 +923,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
       };
@@ -784,6 +942,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) => {