@dropthis/cli 0.5.0 → 0.6.1

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

@@ -11,16 +11,358 @@ function createErrorResult(code, message, statusCode, extra = {}) {
       message: redactSecrets(message),
       statusCode,
       ...extra.type ? { type: extra.type } : {},
+      ...extra.title !== void 0 ? { title: extra.title } : {},
       ...extra.detail !== void 0 ? { detail: extra.detail } : {},
+      ...extra.instance !== void 0 ? { instance: extra.instance } : {},
       ...extra.param !== void 0 ? { param: extra.param } : {},
       ...extra.currentRevision !== void 0 ? { currentRevision: extra.currentRevision } : {},
       ...extra.requestId !== void 0 ? { requestId: extra.requestId } : {},
       ...extra.suggestion !== void 0 ? { suggestion: extra.suggestion } : {},
-      ...extra.retryable !== void 0 ? { retryable: extra.retryable } : {}
+      ...extra.retryable !== void 0 ? { retryable: extra.retryable } : {},
+      ...extra.body !== void 0 ? { body: extra.body } : {}
     },
     headers: extra.headers ?? {}
   };
 }
+var PublishInputError = class extends Error {
+  constructor(code, message, param, suggestion) {
+    super(message);
+    this.code = code;
+    this.param = param;
+    this.suggestion = suggestion;
+    this.name = "PublishInputError";
+  }
+  code;
+  param;
+  suggestion;
+};
+function toErrorResult(err) {
+  if (err instanceof PublishInputError)
+    return createErrorResult(err.code, err.message, null, {
+      param: err.param ?? null,
+      suggestion: err.suggestion ?? null
+    });
+  return createErrorResult(
+    "sdk_error",
+    err instanceof Error ? err.message : "Unknown SDK error",
+    null
+  );
+}
+
+// src/publish/detect.ts
+function isHttpUrl(value) {
+  try {
+    const url = new URL(value);
+    return url.protocol === "http:" || url.protocol === "https:";
+  } catch {
+    return false;
+  }
+}
+function containsHtmlTag(value) {
+  return /<[a-z!/][^>]*>/i.test(value);
+}
+function contentTypeForString(value, override) {
+  if (override) return override;
+  return containsHtmlTag(value) ? "text/html" : "text/plain; charset=utf-8";
+}
+function detectBytesContentType(bytes) {
+  const text = new TextDecoder("utf-8", { fatal: false }).decode(bytes);
+  if (text.includes("\uFFFD")) return "application/octet-stream";
+  return containsHtmlTag(text) ? "text/html" : "text/plain; charset=utf-8";
+}
+function entryForContentType(contentType) {
+  const m = contentType.toLowerCase().split(";", 1)[0]?.trim() ?? "";
+  if (m === "text/html" || m === "application/xhtml+xml") return "index.html";
+  if (m === "application/json") return "index.json";
+  if (m === "text/css") return "index.css";
+  if (m === "text/javascript" || m === "application/javascript")
+    return "index.js";
+  if (m.startsWith("text/")) return "index.txt";
+  return "index";
+}
+
+// src/publish/paths.ts
+function normalizeManifestPath(path) {
+  return path.replace(/\\/g, "/").replace(/^\.\//, "");
+}
+function assertValidManifestPath(path) {
+  if (path.includes("\\"))
+    throw new PublishInputError(
+      "invalid_path",
+      `Manifest path must use "/": "${path}".`,
+      path
+    );
+  const p = normalizeManifestPath(path);
+  if (p === "")
+    throw new PublishInputError(
+      "invalid_path",
+      "Manifest path must not be empty.",
+      path
+    );
+  if (p.startsWith("/"))
+    throw new PublishInputError(
+      "invalid_path",
+      `Manifest path must be relative: "${path}".`,
+      path
+    );
+  if (p.startsWith("~"))
+    throw new PublishInputError(
+      "invalid_path",
+      `Manifest path must not start with "~": "${path}".`,
+      path
+    );
+  if (p.split("/").includes(".."))
+    throw new PublishInputError(
+      "invalid_path",
+      `Manifest path must not contain "..": "${path}".`,
+      path
+    );
+}
+function assertNoDuplicatePaths(paths) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const raw of paths) {
+    const p = normalizeManifestPath(raw);
+    if (seen.has(p))
+      throw new PublishInputError(
+        "duplicate_path",
+        `Duplicate file path after normalization: "${p}".`,
+        p,
+        "Give each file a unique path; basename mapping for string[] can collide."
+      );
+    seen.add(p);
+  }
+}
+function assertNonEmptyBundle(paths) {
+  if (paths.length === 0)
+    throw new PublishInputError(
+      "empty_bundle",
+      "Nothing to publish: the bundle has no files.",
+      void 0,
+      "Pass at least one file, or a directory that contains files."
+    );
+}
+
+// src/publish/core.ts
+var VALID_VISIBILITIES = ["public", "unlisted"];
+var MAX_TITLE_LENGTH = 500;
+function validatePublishOptions(options) {
+  if (options.title !== void 0 && options.title !== null && options.title.length > MAX_TITLE_LENGTH) {
+    throw new Error(`Title must be ${MAX_TITLE_LENGTH} characters or less.`);
+  }
+  if (options.visibility !== void 0 && options.visibility !== null) {
+    if (!VALID_VISIBILITIES.includes(options.visibility)) {
+      throw new Error(
+        `Invalid visibility "${options.visibility}". Use "public" or "unlisted".`
+      );
+    }
+  }
+  if (options.expiresAt !== void 0 && options.expiresAt !== null) {
+    if (options.expiresAt instanceof Date) {
+      if (Number.isNaN(options.expiresAt.getTime())) {
+        throw new Error("Invalid expiresAt date.");
+      }
+    } else if (typeof options.expiresAt === "string") {
+      const parsed = new Date(options.expiresAt);
+      if (Number.isNaN(parsed.getTime())) {
+        throw new Error("Invalid expiresAt date.");
+      }
+    }
+  }
+}
+function optionsBody(options) {
+  validatePublishOptions(options);
+  return {
+    title: options.title,
+    visibility: options.visibility,
+    password: options.password,
+    noindex: options.noindex,
+    expiresAt: options.expiresAt instanceof Date ? options.expiresAt.toISOString() : options.expiresAt
+  };
+}
+function buildStagedRequest(files, options, entry) {
+  assertNonEmptyBundle(files.map((f) => f.path));
+  const normalizedPaths = files.map((f) => normalizeManifestPath(f.path));
+  assertNoDuplicatePaths(normalizedPaths);
+  const manifestFiles = files.map((file) => ({
+    path: normalizeManifestPath(file.path),
+    contentType: file.contentType,
+    sizeBytes: file.sizeBytes,
+    ...file.checksumSha256 ? { checksumSha256: file.checksumSha256 } : {}
+  }));
+  const resolvedEntry = entry ?? options.entry;
+  if (resolvedEntry !== void 0) assertValidManifestPath(resolvedEntry);
+  const manifest = {
+    schemaVersion: 1,
+    files: manifestFiles,
+    ...resolvedEntry ? { entry: resolvedEntry } : {}
+  };
+  const prepared = {
+    kind: "staged",
+    manifest,
+    files,
+    options: optionsBody(options)
+  };
+  if (options.metadata) prepared.metadata = options.metadata;
+  return prepared;
+}
+function buildSourceRequest(sourceUrl, options) {
+  if (!isHttpUrl(sourceUrl)) {
+    throw new PublishInputError(
+      "invalid_source_url",
+      "source_url must be an http(s) URL.",
+      sourceUrl,
+      "Fetch the content first, then pass it as content/files."
+    );
+  }
+  const prepared = {
+    kind: "source",
+    sourceUrl,
+    options: optionsBody(options)
+  };
+  if (options.metadata) prepared.metadata = options.metadata;
+  return prepared;
+}
+function decodeBase64(value) {
+  const binary = atob(value);
+  return Uint8Array.from(binary, (c) => c.charCodeAt(0));
+}
+function fileBytes(file) {
+  if (file.content !== void 0) return new TextEncoder().encode(file.content);
+  if (file.contentBase64 !== void 0) return decodeBase64(file.contentBase64);
+  if (file.bytes !== void 0) return file.bytes;
+  throw new PublishInputError(
+    "missing_file_bytes",
+    `File "${file.path}" is missing content bytes.`,
+    file.path,
+    "Provide one of content, contentBase64, or bytes."
+  );
+}
+function singleStagedFile(path, contentType, bytes, options) {
+  return buildStagedRequest(
+    [
+      {
+        path,
+        contentType,
+        sizeBytes: bytes.byteLength,
+        getBody: async () => bytes
+      }
+    ],
+    options
+  );
+}
+async function resolveInMemory(input, options = {}) {
+  if (input instanceof URL) {
+    return buildSourceRequest(input.toString(), options);
+  }
+  if (typeof input === "string") {
+    if (isHttpUrl(input)) return buildSourceRequest(input, options);
+    const contentType = contentTypeForString(input, options.contentType);
+    if (options.path !== void 0) assertValidManifestPath(options.path);
+    const path = options.path ?? entryForContentType(contentType);
+    const bytes = new TextEncoder().encode(input);
+    return singleStagedFile(path, contentType, bytes, options);
+  }
+  if (input instanceof Uint8Array) {
+    const contentType = options.contentType ?? detectBytesContentType(input);
+    if (options.path !== void 0) assertValidManifestPath(options.path);
+    const path = options.path ?? entryForContentType(contentType);
+    return singleStagedFile(path, contentType, input, options);
+  }
+  if (input.kind === "content") {
+    const contentType = input.contentType ?? options.contentType ?? "text/html";
+    if (input.path !== void 0) assertValidManifestPath(input.path);
+    if (options.path !== void 0) assertValidManifestPath(options.path);
+    const path = input.path ?? options.path ?? entryForContentType(contentType);
+    const bytes = new TextEncoder().encode(input.content);
+    return singleStagedFile(path, contentType, bytes, options);
+  }
+  if (input.kind === "source_url") {
+    return buildSourceRequest(input.sourceUrl, options);
+  }
+  const files = input.files.map((file) => {
+    assertValidManifestPath(file.path);
+    const bytes = fileBytes(file);
+    const contentType = file.contentType ?? detectBytesContentType(bytes);
+    return {
+      path: file.path,
+      contentType,
+      sizeBytes: bytes.byteLength,
+      getBody: async () => bytes
+    };
+  });
+  return buildStagedRequest(files, options, input.entry);
+}
+function errorResult(result) {
+  if (!result.error) throw new Error("Expected an error result");
+  return { data: null, error: result.error, headers: result.headers };
+}
+async function publishStaged(transport, prepared, finalPath, options = {}) {
+  const baseKey = options.idempotencyKey ?? `sdk-${crypto.randomUUID()}`;
+  const createResult = await transport.request(
+    "POST",
+    "/uploads",
+    {
+      body: prepared.manifest,
+      idempotencyKey: `${baseKey}:create-upload`
+    }
+  );
+  if (createResult.error) return errorResult(createResult);
+  for (const file of prepared.files) {
+    const target = createResult.data.files.find((f) => f.path === file.path);
+    if (!target) {
+      return createErrorResult(
+        "upload_target_missing",
+        `Upload target missing for ${file.path}`,
+        null
+      );
+    }
+    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.`,
+        null
+      );
+    }
+    const put = await transport.putSignedUrl(
+      target.upload.url,
+      await file.getBody(),
+      target.upload.headers
+    );
+    if (put.error) return errorResult(put);
+  }
+  const completeResult = await transport.request(
+    "POST",
+    `/uploads/${encodeURIComponent(createResult.data.uploadId)}/complete`,
+    {
+      body: { files: {} },
+      idempotencyKey: `${baseKey}:complete-upload`
+    }
+  );
+  if (completeResult.error) return errorResult(completeResult);
+  const finalOptions = {
+    body: {
+      uploadId: createResult.data.uploadId,
+      options: prepared.options,
+      ...prepared.metadata ? { metadata: prepared.metadata } : {}
+    },
+    idempotencyKey: `${baseKey}:publish`
+  };
+  if (options.ifRevision !== void 0)
+    finalOptions.ifRevision = options.ifRevision;
+  return transport.request("POST", finalPath, finalOptions);
+}
+async function publishSource(transport, prepared, finalPath, options = {}) {
+  const baseKey = options.idempotencyKey ?? `sdk-${crypto.randomUUID()}`;
+  return transport.request("POST", finalPath, {
+    body: {
+      sourceUrl: prepared.sourceUrl,
+      options: prepared.options,
+      ...prepared.metadata ? { metadata: prepared.metadata } : {}
+    },
+    idempotencyKey: `${baseKey}:publish`,
+    ...options.ifRevision !== void 0 ? { ifRevision: options.ifRevision } : {}
+  });
+}
 
 // src/resources/account.ts
 var AccountResource = class {
@@ -65,33 +407,6 @@ var DeploymentsResource = class {
     this.transport = transport;
   }
   transport;
-  create(dropId, body, options = {}) {
-    const requestOptions = { body };
-    if (options.idempotencyKey)
-      requestOptions.idempotencyKey = options.idempotencyKey;
-    if (options.ifRevision !== void 0)
-      requestOptions.ifRevision = options.ifRevision;
-    return this.transport.request(
-      "POST",
-      `/drops/${encodeURIComponent(dropId)}/deployments`,
-      requestOptions
-    );
-  }
-  createRaw(dropId, body, options = {}) {
-    const requestOptions = {
-      body,
-      bodyCase: "raw"
-    };
-    if (options.idempotencyKey)
-      requestOptions.idempotencyKey = options.idempotencyKey;
-    if (options.ifRevision !== void 0)
-      requestOptions.ifRevision = options.ifRevision;
-    return this.transport.request(
-      "POST",
-      `/drops/${encodeURIComponent(dropId)}/deployments`,
-      requestOptions
-    );
-  }
   list(dropId, params = {}) {
     return this.transport.request(
       "GET",
@@ -146,21 +461,6 @@ var DropsResource = class {
     this.transport = transport;
   }
   transport;
-  create(body, options = {}) {
-    const requestOptions = { body };
-    if (options.idempotencyKey)
-      requestOptions.idempotencyKey = options.idempotencyKey;
-    return this.transport.request("POST", "/drops", requestOptions);
-  }
-  createRaw(body, options = {}) {
-    const requestOptions = {
-      body,
-      bodyCase: "raw"
-    };
-    if (options.idempotencyKey)
-      requestOptions.idempotencyKey = options.idempotencyKey;
-    return this.transport.request("POST", "/drops", requestOptions);
-  }
   async list(params = {}) {
     const result = await this.transport.request("GET", "/drops", {
       params
@@ -201,15 +501,22 @@ var DropsResource = class {
     );
   }
 };
+var SETTINGS = [
+  "title",
+  "visibility",
+  "password",
+  "noindex",
+  "expiresAt",
+  "slug"
+];
 function updateBody(options) {
-  const {
-    metadata,
-    idempotencyKey: _idempotencyKey,
-    ifRevision: _ifRevision,
-    entry: _entry,
-    ...dropOptions2
-  } = options;
-  return { options: dropOptions2, metadata };
+  const out = {};
+  for (const key of SETTINGS)
+    if (options[key] !== void 0) out[key] = options[key];
+  return {
+    options: out,
+    ...options.metadata !== void 0 ? { metadata: options.metadata } : {}
+  };
 }
 
 // src/case.ts
@@ -247,25 +554,24 @@ function toSnakeCase(value) {
 
 // src/transport.ts
 var DEFAULT_BASE_URL = "https://api.dropthis.app";
-var SDK_VERSION = "0.5.0";
+var SDK_VERSION = "0.6.0";
 var Transport = class {
   apiKey;
   baseUrl;
   timeoutMs;
+  uploadTimeoutMs;
   fetchImpl;
   constructor(options = {}) {
     const resolved = typeof options === "string" ? { apiKey: options } : options;
     this.apiKey = resolved.apiKey ?? (typeof process !== "undefined" ? process.env?.DROPTHIS_API_KEY : void 0);
     this.baseUrl = (resolved.baseUrl ?? DEFAULT_BASE_URL).replace(/\/+$/, "");
     this.timeoutMs = resolved.timeoutMs ?? 3e4;
+    this.uploadTimeoutMs = resolved.uploadTimeoutMs ?? 12e4;
     this.fetchImpl = resolved.fetch ?? globalThis.fetch;
   }
-  multipart(method, path, form, options = {}) {
-    return this.request(method, path, { ...options, body: form });
-  }
   async putSignedUrl(url, body, headers) {
     const controller = new AbortController();
-    const timeout = setTimeout(() => controller.abort(), this.timeoutMs);
+    const timeout = setTimeout(() => controller.abort(), this.uploadTimeoutMs);
     try {
       const request = {
         method: "PUT",
@@ -320,7 +626,7 @@ var Transport = class {
     if (options.idempotencyKey)
       headers["idempotency-key"] = options.idempotencyKey;
     if (options.ifRevision !== void 0)
-      headers["If-Revision"] = String(options.ifRevision);
+      headers["if-revision"] = String(options.ifRevision);
     if (options.body !== void 0 && !(options.body instanceof FormData))
       headers["content-type"] = "application/json";
     const url = new URL(`${this.baseUrl}${path}`);
@@ -352,11 +658,18 @@ var Transport = class {
       const parsed = parseJson(text);
       if (!response.ok) {
         const body = parsed && typeof parsed === "object" ? parsed : {};
-        const message = stringValue(body.detail) ?? stringValue(body.error) ?? stringValue(body.message) ?? response.statusText;
+        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, {
-          detail: body,
+          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,
@@ -408,106 +721,6 @@ function booleanValue(value) {
 }
 
 // src/edge.ts
-var DROP_OPTION_KEYS = [
-  "title",
-  "visibility",
-  "password",
-  "noindex",
-  "expiresAt"
-];
-function detectStringContentType(value) {
-  const trimmed = value.trimStart().toLowerCase();
-  if (trimmed.startsWith("<!doctype html") || trimmed.startsWith("<html") || /^<[a-z][a-z0-9:-]*(\s|>)/.test(trimmed)) {
-    return "text/html";
-  }
-  return "text/plain; charset=utf-8";
-}
-function defaultEntry(contentType) {
-  const media = contentType.split(";", 1)[0]?.trim().toLowerCase() ?? "";
-  return media === "text/html" ? "index.html" : "index.txt";
-}
-function normalizeInput(input, options) {
-  if (typeof input === "string") {
-    const contentType = options.contentType ?? detectStringContentType(input);
-    return {
-      bytes: new TextEncoder().encode(input),
-      path: options.path ?? defaultEntry(contentType),
-      contentType
-    };
-  }
-  return {
-    bytes: input.bytes,
-    path: input.filename ?? options.path ?? "index.html",
-    contentType: input.contentType ?? options.contentType ?? "application/octet-stream"
-  };
-}
-function dropOptions(options) {
-  const out = {};
-  for (const key of DROP_OPTION_KEYS) {
-    if (options[key] !== void 0) out[key] = options[key];
-  }
-  return out;
-}
-function errorResult(result) {
-  if (!result.error) throw new Error("Expected an error result");
-  return { data: null, error: result.error, headers: result.headers };
-}
-async function stagedInline(transport, input, options, finalPath) {
-  const { bytes, path, contentType } = normalizeInput(input, options);
-  const baseKey = options.idempotencyKey ?? `mcp-${crypto.randomUUID()}`;
-  const manifest = {
-    schemaVersion: 1,
-    files: [{ path, contentType, sizeBytes: bytes.byteLength }],
-    entry: path
-  };
-  const created = await transport.request(
-    "POST",
-    "/uploads",
-    {
-      body: manifest,
-      idempotencyKey: `${baseKey}:create-upload`
-    }
-  );
-  if (created.error) return errorResult(created);
-  const target = created.data.files[0];
-  if (!target) {
-    return createErrorResult(
-      "upload_target_missing",
-      "No upload target returned for the file.",
-      null
-    );
-  }
-  if (target.upload.strategy !== "single_put") {
-    return createErrorResult(
-      "unsupported_upload_strategy",
-      "Edge publishInline supports single_put uploads only; the content is too large for inline publishing.",
-      null
-    );
-  }
-  const put = await transport.putSignedUrl(
-    target.upload.url,
-    bytes,
-    target.upload.headers
-  );
-  if (put.error) return errorResult(put);
-  const completed = await transport.request(
-    "POST",
-    `/uploads/${encodeURIComponent(created.data.uploadId)}/complete`,
-    { body: { files: {} }, idempotencyKey: `${baseKey}:complete-upload` }
-  );
-  if (completed.error) return errorResult(completed);
-  const finalOptions = {
-    body: {
-      uploadId: created.data.uploadId,
-      options: dropOptions(options),
-      ...options.metadata ? { metadata: options.metadata } : {}
-    },
-    idempotencyKey: `${baseKey}:publish`
-  };
-  if (options.ifRevision !== void 0)
-    finalOptions.ifRevision = options.ifRevision;
-  return transport.request("POST", finalPath, finalOptions);
-}
 var DropthisEdge = class {
   transport;
   dropsResource;
@@ -538,17 +751,25 @@ var DropthisEdge = class {
     return this.deploymentsResource;
   }
   /** Publish a NEW drop from in-memory content. */
-  publishInline(input, options = {}) {
-    return stagedInline(this.transport, input, options, "/drops");
+  async publish(input, options = {}) {
+    let prepared;
+    try {
+      prepared = await resolveInMemory(input, options);
+    } catch (e) {
+      return toErrorResult(e);
+    }
+    return prepared.kind === "source" ? publishSource(this.transport, prepared, "/drops", options) : publishStaged(this.transport, prepared, "/drops", options);
   }
   /** Publish a NEW content version to an existing drop, keeping its URL. */
-  deployInline(dropId, input, options = {}) {
-    return stagedInline(
-      this.transport,
-      input,
-      options,
-      `/drops/${encodeURIComponent(dropId)}/deployments`
-    );
+  async deploy(dropId, input, options = {}) {
+    let prepared;
+    try {
+      prepared = await resolveInMemory(input, options);
+    } catch (e) {
+      return toErrorResult(e);
+    }
+    const path = `/drops/${encodeURIComponent(dropId)}/deployments`;
+    return prepared.kind === "source" ? publishSource(this.transport, prepared, path, options) : publishStaged(this.transport, prepared, path, options);
   }
 };
 export {