@dropthis/cli 0.4.1 → 0.5.0

package/node_modules/@dropthis/node/dist/edge.d.cts

@@ -0,0 +1,49 @@
+import { m as DropthisClientOptions, l as DropsResource, A as AccountResource, b as ApiKeysResource, D as DeploymentsResource, o as DropthisResult, k as DropResponse } from './drops-fK63OCk6.cjs';
+
+/** In-memory publish input: an HTML/text string, or raw bytes with a filename + content type. */
+type InlineInput = string | {
+    bytes: Uint8Array;
+    filename?: string;
+    contentType?: string;
+};
+type PublishInlineOptions = {
+    /** Drop title. */
+    title?: string;
+    /** Serving visibility. */
+    visibility?: "public" | "unlisted";
+    /** Require a password to view (Pro). */
+    password?: string | null;
+    /** Force search engines not to index. */
+    noindex?: boolean | null;
+    /** Set or clear automatic expiry (ISO 8601). */
+    expiresAt?: string | null;
+    /** Override the entry path/filename for string input (default index.html). */
+    path?: string;
+    /** Override the detected content type for string input. */
+    contentType?: string;
+    /** Custom drop metadata. */
+    metadata?: Record<string, unknown>;
+    /** Idempotency key base; one is generated if omitted. */
+    idempotencyKey?: string;
+    /** Optimistic-concurrency revision for deployments. */
+    ifRevision?: number;
+};
+/** Workers-safe dropthis client. Pass an apiKey explicitly (no process.env on the edge). */
+declare class DropthisEdge {
+    private readonly transport;
+    private dropsResource?;
+    private accountResource?;
+    private apiKeysResource?;
+    private deploymentsResource?;
+    constructor(options?: DropthisClientOptions | string);
+    get drops(): DropsResource;
+    get account(): AccountResource;
+    get apiKeys(): ApiKeysResource;
+    get deployments(): DeploymentsResource;
+    /** Publish a NEW drop from in-memory content. */
+    publishInline(input: InlineInput, options?: PublishInlineOptions): Promise<DropthisResult<DropResponse>>;
+    /** Publish a NEW content version to an existing drop, keeping its URL. */
+    deployInline(dropId: string, input: InlineInput, options?: PublishInlineOptions): Promise<DropthisResult<DropResponse>>;
+}
+
+export { DropthisEdge, type InlineInput, type PublishInlineOptions };

package/node_modules/@dropthis/node/dist/edge.d.ts

@@ -0,0 +1,49 @@
+import { m as DropthisClientOptions, l as DropsResource, A as AccountResource, b as ApiKeysResource, D as DeploymentsResource, o as DropthisResult, k as DropResponse } from './drops-fK63OCk6.js';
+
+/** In-memory publish input: an HTML/text string, or raw bytes with a filename + content type. */
+type InlineInput = string | {
+    bytes: Uint8Array;
+    filename?: string;
+    contentType?: string;
+};
+type PublishInlineOptions = {
+    /** Drop title. */
+    title?: string;
+    /** Serving visibility. */
+    visibility?: "public" | "unlisted";
+    /** Require a password to view (Pro). */
+    password?: string | null;
+    /** Force search engines not to index. */
+    noindex?: boolean | null;
+    /** Set or clear automatic expiry (ISO 8601). */
+    expiresAt?: string | null;
+    /** Override the entry path/filename for string input (default index.html). */
+    path?: string;
+    /** Override the detected content type for string input. */
+    contentType?: string;
+    /** Custom drop metadata. */
+    metadata?: Record<string, unknown>;
+    /** Idempotency key base; one is generated if omitted. */
+    idempotencyKey?: string;
+    /** Optimistic-concurrency revision for deployments. */
+    ifRevision?: number;
+};
+/** Workers-safe dropthis client. Pass an apiKey explicitly (no process.env on the edge). */
+declare class DropthisEdge {
+    private readonly transport;
+    private dropsResource?;
+    private accountResource?;
+    private apiKeysResource?;
+    private deploymentsResource?;
+    constructor(options?: DropthisClientOptions | string);
+    get drops(): DropsResource;
+    get account(): AccountResource;
+    get apiKeys(): ApiKeysResource;
+    get deployments(): DeploymentsResource;
+    /** Publish a NEW drop from in-memory content. */
+    publishInline(input: InlineInput, options?: PublishInlineOptions): Promise<DropthisResult<DropResponse>>;
+    /** Publish a NEW content version to an existing drop, keeping its URL. */
+    deployInline(dropId: string, input: InlineInput, options?: PublishInlineOptions): Promise<DropthisResult<DropResponse>>;
+}
+
+export { DropthisEdge, type InlineInput, type PublishInlineOptions };

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

@@ -0,0 +1,557 @@
+// src/errors.ts
+var API_KEY_RE = /sk_[A-Za-z0-9_-]+/g;
+function redactSecrets(message) {
+  return message.replace(API_KEY_RE, "sk_[redacted]");
+}
+function createErrorResult(code, message, statusCode, extra = {}) {
+  return {
+    data: null,
+    error: {
+      code,
+      message: redactSecrets(message),
+      statusCode,
+      ...extra.type ? { type: extra.type } : {},
+      ...extra.detail !== void 0 ? { detail: extra.detail } : {},
+      ...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 } : {}
+    },
+    headers: extra.headers ?? {}
+  };
+}
+
+// src/resources/account.ts
+var AccountResource = class {
+  constructor(transport) {
+    this.transport = transport;
+  }
+  transport;
+  get() {
+    return this.transport.request("GET", "/account");
+  }
+  update(input) {
+    return this.transport.request("PATCH", "/account", { body: input });
+  }
+  delete() {
+    return this.transport.request("DELETE", "/account");
+  }
+};
+
+// src/resources/api-keys.ts
+var ApiKeysResource = class {
+  constructor(transport) {
+    this.transport = transport;
+  }
+  transport;
+  list() {
+    return this.transport.request("GET", "/api-keys");
+  }
+  create(input) {
+    return this.transport.request("POST", "/api-keys", { body: input });
+  }
+  delete(keyId) {
+    return this.transport.request(
+      "DELETE",
+      `/api-keys/${encodeURIComponent(keyId)}`
+    );
+  }
+};
+
+// src/resources/deployments.ts
+var DeploymentsResource = class {
+  constructor(transport) {
+    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",
+      `/drops/${encodeURIComponent(dropId)}/deployments`,
+      { params }
+    );
+  }
+  get(dropId, deploymentId) {
+    return this.transport.request(
+      "GET",
+      `/drops/${encodeURIComponent(dropId)}/deployments/${encodeURIComponent(deploymentId)}`
+    );
+  }
+};
+
+// src/pagination.ts
+var CursorPage = class {
+  object = "list";
+  data;
+  hasMore;
+  nextCursor;
+  fetchNextPage;
+  constructor(input) {
+    this.data = input.data;
+    this.hasMore = input.hasMore;
+    this.nextCursor = input.nextCursor;
+    this.fetchNextPage = input.fetchNextPage;
+  }
+  async autoPagingToArray(options = {}) {
+    const items = [];
+    for await (const item of this) {
+      items.push(item);
+      if (options.limit !== void 0 && items.length >= options.limit) break;
+    }
+    return items;
+  }
+  async *[Symbol.asyncIterator]() {
+    for (const item of this.data) yield item;
+    let current = this;
+    while (current.hasMore && current.fetchNextPage) {
+      const next = await current.fetchNextPage();
+      if (next.error) break;
+      current = next.data;
+      for (const item of current.data) yield item;
+    }
+  }
+};
+
+// src/resources/drops.ts
+var DropsResource = class {
+  constructor(transport) {
+    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
+    });
+    if (result.error) return result;
+    const page = new CursorPage({
+      data: result.data.drops,
+      nextCursor: result.data.nextCursor,
+      hasMore: result.data.nextCursor !== null,
+      fetchNextPage: result.data.nextCursor ? () => this.list({ ...params, cursor: result.data.nextCursor }) : void 0
+    });
+    return { data: page, error: null, headers: result.headers };
+  }
+  get(dropId) {
+    return this.transport.request(
+      "GET",
+      `/drops/${encodeURIComponent(dropId)}`
+    );
+  }
+  update(dropId, options = {}) {
+    const requestOptions = {
+      body: updateBody(options)
+    };
+    if (options.idempotencyKey)
+      requestOptions.idempotencyKey = options.idempotencyKey;
+    if (options.ifRevision !== void 0)
+      requestOptions.ifRevision = options.ifRevision;
+    return this.transport.request(
+      "PATCH",
+      `/drops/${encodeURIComponent(dropId)}`,
+      requestOptions
+    );
+  }
+  delete(dropId) {
+    return this.transport.request(
+      "DELETE",
+      `/drops/${encodeURIComponent(dropId)}`
+    );
+  }
+};
+function updateBody(options) {
+  const {
+    metadata,
+    idempotencyKey: _idempotencyKey,
+    ifRevision: _ifRevision,
+    entry: _entry,
+    ...dropOptions2
+  } = options;
+  return { options: dropOptions2, metadata };
+}
+
+// src/case.ts
+function toCamelKey(key) {
+  return key.replace(/_([a-z])/g, (_, char) => char.toUpperCase());
+}
+function toSnakeKey(key) {
+  return key.replace(/[A-Z]/g, (char) => `_${char.toLowerCase()}`);
+}
+var PASSTHROUGH_KEYS = /* @__PURE__ */ new Set(["metadata"]);
+function toCamelCase(value) {
+  if (Array.isArray(value)) return value.map(toCamelCase);
+  if (value && typeof value === "object") {
+    return Object.fromEntries(
+      Object.entries(value).map(([key, item]) => [
+        toCamelKey(key),
+        PASSTHROUGH_KEYS.has(key) ? item : toCamelCase(item)
+      ])
+    );
+  }
+  return value;
+}
+function toSnakeCase(value) {
+  if (Array.isArray(value)) return value.map(toSnakeCase);
+  if (value && typeof value === "object") {
+    return Object.fromEntries(
+      Object.entries(value).filter(([, item]) => item !== void 0).map(([key, item]) => [
+        toSnakeKey(key),
+        PASSTHROUGH_KEYS.has(key) ? item : toSnakeCase(item)
+      ])
+    );
+  }
+  return value;
+}
+
+// src/transport.ts
+var DEFAULT_BASE_URL = "https://api.dropthis.app";
+var SDK_VERSION = "0.5.0";
+var Transport = class {
+  apiKey;
+  baseUrl;
+  timeoutMs;
+  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.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);
+    try {
+      const request = {
+        method: "PUT",
+        headers,
+        body,
+        signal: controller.signal
+      };
+      if (body instanceof ReadableStream) request.duplex = "half";
+      const response = await this.fetchImpl(url, request);
+      const responseHeaders = headersToObject(response.headers);
+      if (!response.ok) {
+        const text = await response.text();
+        return createErrorResult(
+          `signed_upload_${response.status}`,
+          text || response.statusText,
+          response.status,
+          { headers: responseHeaders }
+        );
+      }
+      return {
+        data: {
+          etag: response.headers.get("ETag") ?? responseHeaders.etag ?? 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) {
+      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}`
+    };
+    if (authenticated && this.apiKey)
+      headers.authorization = `Bearer ${this.apiKey}`;
+    if (options.idempotencyKey)
+      headers["idempotency-key"] = options.idempotencyKey;
+    if (options.ifRevision !== void 0)
+      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}`);
+    const wireParams = options.bodyCase === "raw" ? options.params : toSnakeCase(options.params ?? {});
+    for (const [key, value] of Object.entries(wireParams ?? {})) {
+      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 request = {
+        method,
+        headers,
+        signal: controller.signal
+      };
+      if (options.body instanceof FormData) {
+        request.body = options.body;
+      } else if (options.body !== void 0) {
+        const wireBody = options.bodyCase === "raw" ? options.body : toSnakeCase(options.body);
+        request.body = JSON.stringify(wireBody);
+      }
+      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.error) ?? stringValue(body.message) ?? response.statusText;
+        const code = stringValue(body.code) ?? stringValue(body.error_code) ?? `http_${response.status}`;
+        const currentRevision = numberValue(body.current_revision);
+        return createErrorResult(code, message, response.status, {
+          detail: body,
+          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
+        });
+      }
+      return {
+        data: toCamelCase(parsed),
+        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);
+    }
+  }
+};
+function headersToObject(headers) {
+  const result = {};
+  headers.forEach((value, key) => {
+    result[key.toLowerCase()] = value;
+  });
+  return result;
+}
+function parseJson(text) {
+  if (!text) return null;
+  try {
+    return JSON.parse(text);
+  } catch {
+    return text;
+  }
+}
+function stringValue(value) {
+  return typeof value === "string" ? value : null;
+}
+function numberValue(value) {
+  return typeof value === "number" ? value : void 0;
+}
+function booleanValue(value) {
+  return typeof value === "boolean" ? value : null;
+}
+
+// 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;
+  accountResource;
+  apiKeysResource;
+  deploymentsResource;
+  constructor(options = {}) {
+    this.transport = new Transport(options);
+  }
+  get drops() {
+    if (!this.dropsResource)
+      this.dropsResource = new DropsResource(this.transport);
+    return this.dropsResource;
+  }
+  get account() {
+    if (!this.accountResource)
+      this.accountResource = new AccountResource(this.transport);
+    return this.accountResource;
+  }
+  get apiKeys() {
+    if (!this.apiKeysResource)
+      this.apiKeysResource = new ApiKeysResource(this.transport);
+    return this.apiKeysResource;
+  }
+  get deployments() {
+    if (!this.deploymentsResource)
+      this.deploymentsResource = new DeploymentsResource(this.transport);
+    return this.deploymentsResource;
+  }
+  /** Publish a NEW drop from in-memory content. */
+  publishInline(input, options = {}) {
+    return stagedInline(this.transport, input, options, "/drops");
+  }
+  /** 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`
+    );
+  }
+};
+export {
+  DropthisEdge
+};
+//# sourceMappingURL=edge.mjs.map