@hasna/connectors 1.3.31 → 1.3.33

package/connectors/connect-cloudflare/dist/index.js

@@ -1,2195 +0,0 @@
-// @bun
-// src/types/index.ts
-class CloudflareApiError extends Error {
-  statusCode;
-  errors;
-  constructor(message, statusCode, errors = []) {
-    super(message);
-    this.name = "CloudflareApiError";
-    this.statusCode = statusCode;
-    this.errors = errors;
-  }
-}
-
-// src/api/client.ts
-var DEFAULT_BASE_URL = "https://api.cloudflare.com/client/v4";
-
-class CloudflareClient {
-  apiToken;
-  apiKey;
-  email;
-  accountId;
-  baseUrl;
-  constructor(config) {
-    if (!config.apiToken && !(config.apiKey && config.email)) {
-      throw new Error("Either API token or (API key + email) is required");
-    }
-    this.apiToken = config.apiToken;
-    this.apiKey = config.apiKey;
-    this.email = config.email;
-    this.accountId = config.accountId;
-    this.baseUrl = config.baseUrl || DEFAULT_BASE_URL;
-  }
-  buildUrl(path, params) {
-    const url = new URL(`${this.baseUrl}${path}`);
-    if (params) {
-      Object.entries(params).forEach(([key, value]) => {
-        if (value !== undefined && value !== null && value !== "") {
-          url.searchParams.append(key, String(value));
-        }
-      });
-    }
-    return url.toString();
-  }
-  getAuthHeaders() {
-    if (this.apiToken) {
-      return {
-        Authorization: `Bearer ${this.apiToken}`
-      };
-    }
-    if (this.apiKey && this.email) {
-      return {
-        "X-Auth-Key": this.apiKey,
-        "X-Auth-Email": this.email
-      };
-    }
-    throw new Error("No valid authentication configured");
-  }
-  async request(path, options = {}) {
-    const { method = "GET", params, body, headers = {}, rawBody = false, rawResponse = false } = options;
-    const url = this.buildUrl(path, params);
-    const requestHeaders = {
-      ...this.getAuthHeaders(),
-      ...headers
-    };
-    if (body && !rawBody && !(body instanceof FormData)) {
-      requestHeaders["Content-Type"] = "application/json";
-    }
-    const fetchOptions = {
-      method,
-      headers: requestHeaders
-    };
-    if (body) {
-      if (body instanceof FormData) {
-        fetchOptions.body = body;
-      } else if (rawBody) {
-        fetchOptions.body = body;
-      } else {
-        fetchOptions.body = JSON.stringify(body);
-      }
-    }
-    const response = await fetch(url, fetchOptions);
-    if (response.status === 204) {
-      return { success: true, result: null, errors: [], messages: [] };
-    }
-    const contentType = response.headers.get("content-type") || "";
-    if (contentType.includes("application/json")) {
-      const text = await response.text();
-      if (!text) {
-        throw new CloudflareApiError("Empty response", response.status);
-      }
-      let data;
-      try {
-        data = JSON.parse(text);
-      } catch {
-        throw new CloudflareApiError(`Invalid JSON response: ${text}`, response.status);
-      }
-      if (rawResponse) {
-        if (!response.ok) {
-          throw new CloudflareApiError(`Request failed with status ${response.status}`, response.status);
-        }
-        return data;
-      }
-      const cfResponse = data;
-      if (!cfResponse.success) {
-        const errorMessages = cfResponse.errors?.map((e) => e.message).join(", ") || "Unknown error";
-        throw new CloudflareApiError(errorMessages, response.status, cfResponse.errors);
-      }
-      return cfResponse;
-    } else {
-      const text = await response.text();
-      if (!response.ok) {
-        throw new CloudflareApiError(text || response.statusText, response.status);
-      }
-      return text;
-    }
-  }
-  async get(path, params) {
-    return this.request(path, { method: "GET", params });
-  }
-  async post(path, body, params) {
-    return this.request(path, { method: "POST", body, params });
-  }
-  async put(path, body, params) {
-    return this.request(path, { method: "PUT", body, params });
-  }
-  async patch(path, body, params) {
-    return this.request(path, { method: "PATCH", body, params });
-  }
-  async delete(path, params) {
-    return this.request(path, { method: "DELETE", params });
-  }
-  async uploadWorkerScript(accountId, scriptName, script, metadata) {
-    const formData = new FormData;
-    const scriptBlob = new Blob([script], { type: "application/javascript" });
-    formData.append("script", scriptBlob, "index.js");
-    if (metadata) {
-      const metadataBlob = new Blob([JSON.stringify(metadata)], { type: "application/json" });
-      formData.append("metadata", metadataBlob);
-    }
-    return this.request(`/accounts/${accountId}/workers/scripts/${scriptName}`, {
-      method: "PUT",
-      body: formData
-    });
-  }
-  getAccountId() {
-    return this.accountId;
-  }
-  getCredentialPreview() {
-    if (this.apiToken) {
-      return `Token: ${this.apiToken.substring(0, 8)}...`;
-    }
-    if (this.apiKey) {
-      return `Key: ${this.apiKey.substring(0, 8)}... (${this.email})`;
-    }
-    return "No credentials";
-  }
-}
-
-// src/api/zones.ts
-class ZonesApi {
-  client;
-  constructor(client) {
-    this.client = client;
-  }
-  async list(params) {
-    return this.client.get("/zones", params);
-  }
-  async get(zoneId) {
-    const response = await this.client.get(`/zones/${zoneId}`);
-    return response.result;
-  }
-  async create(params) {
-    const response = await this.client.post("/zones", params);
-    return response.result;
-  }
-  async delete(zoneId) {
-    const response = await this.client.delete(`/zones/${zoneId}`);
-    return response.result;
-  }
-  async getSettings(zoneId) {
-    const response = await this.client.get(`/zones/${zoneId}/settings`);
-    return response.result;
-  }
-  async getSetting(zoneId, settingId) {
-    const response = await this.client.get(`/zones/${zoneId}/settings/${settingId}`);
-    return response.result;
-  }
-  async updateSetting(zoneId, settingId, value) {
-    const response = await this.client.patch(`/zones/${zoneId}/settings/${settingId}`, { value });
-    return response.result;
-  }
-  async updateSettings(zoneId, items) {
-    const response = await this.client.patch(`/zones/${zoneId}/settings`, { items });
-    return response.result;
-  }
-  async activationCheck(zoneId) {
-    const response = await this.client.put(`/zones/${zoneId}/activation_check`);
-    return response.result;
-  }
-  async pause(zoneId) {
-    const response = await this.client.patch(`/zones/${zoneId}`, { paused: true });
-    return response.result;
-  }
-  async unpause(zoneId) {
-    const response = await this.client.patch(`/zones/${zoneId}`, { paused: false });
-    return response.result;
-  }
-  async enableDevMode(zoneId) {
-    return this.updateSetting(zoneId, "development_mode", "on");
-  }
-  async disableDevMode(zoneId) {
-    return this.updateSetting(zoneId, "development_mode", "off");
-  }
-}
-
-// src/api/dns.ts
-class DNSApi {
-  client;
-  constructor(client) {
-    this.client = client;
-  }
-  async list(zoneId, params) {
-    return this.client.get(`/zones/${zoneId}/dns_records`, params);
-  }
-  async get(zoneId, recordId) {
-    const response = await this.client.get(`/zones/${zoneId}/dns_records/${recordId}`);
-    return response.result;
-  }
-  async create(zoneId, params) {
-    const response = await this.client.post(`/zones/${zoneId}/dns_records`, params);
-    return response.result;
-  }
-  async update(zoneId, recordId, params) {
-    const response = await this.client.put(`/zones/${zoneId}/dns_records/${recordId}`, params);
-    return response.result;
-  }
-  async patch(zoneId, recordId, params) {
-    const response = await this.client.patch(`/zones/${zoneId}/dns_records/${recordId}`, params);
-    return response.result;
-  }
-  async delete(zoneId, recordId) {
-    const response = await this.client.delete(`/zones/${zoneId}/dns_records/${recordId}`);
-    return response.result;
-  }
-  async import(zoneId, bindFile) {
-    const formData = new FormData;
-    const blob = new Blob([bindFile], { type: "text/plain" });
-    formData.append("file", blob, "dns_records.txt");
-    const response = await this.client.request(`/zones/${zoneId}/dns_records/import`, {
-      method: "POST",
-      body: formData
-    });
-    return response.result;
-  }
-  async export(zoneId) {
-    const response = await this.client.request(`/zones/${zoneId}/dns_records/export`, {
-      method: "GET"
-    });
-    return response;
-  }
-  async scan(zoneId) {
-    const response = await this.client.post(`/zones/${zoneId}/dns_records/scan`);
-    return response.result;
-  }
-}
-
-// src/api/workers.ts
-class WorkersApi {
-  client;
-  constructor(client) {
-    this.client = client;
-  }
-  async list(accountId) {
-    return this.client.get(`/accounts/${accountId}/workers/scripts`);
-  }
-  async get(accountId, scriptName) {
-    const response = await this.client.get(`/accounts/${accountId}/workers/scripts/${scriptName}`);
-    return response.result;
-  }
-  async getContent(accountId, scriptName) {
-    return this.client.request(`/accounts/${accountId}/workers/scripts/${scriptName}`, {
-      method: "GET",
-      headers: { Accept: "application/javascript" }
-    });
-  }
-  async create(accountId, scriptName, params) {
-    const metadata = {
-      main_module: "index.js"
-    };
-    if (params.bindings) {
-      metadata.bindings = params.bindings;
-    }
-    if (params.compatibility_date) {
-      metadata.compatibility_date = params.compatibility_date;
-    }
-    if (params.compatibility_flags) {
-      metadata.compatibility_flags = params.compatibility_flags;
-    }
-    if (params.usage_model) {
-      metadata.usage_model = params.usage_model;
-    }
-    const response = await this.client.uploadWorkerScript(accountId, scriptName, params.script, metadata);
-    return response.result;
-  }
-  async update(accountId, scriptName, params) {
-    return this.create(accountId, scriptName, params);
-  }
-  async delete(accountId, scriptName) {
-    await this.client.delete(`/accounts/${accountId}/workers/scripts/${scriptName}`);
-  }
-  async getSettings(accountId, scriptName) {
-    const response = await this.client.get(`/accounts/${accountId}/workers/scripts/${scriptName}/settings`);
-    return response.result;
-  }
-  async updateSettings(accountId, scriptName, settings) {
-    const response = await this.client.patch(`/accounts/${accountId}/workers/scripts/${scriptName}/settings`, settings);
-    return response.result;
-  }
-  async listRoutes(zoneId) {
-    return this.client.get(`/zones/${zoneId}/workers/routes`);
-  }
-  async getRoute(zoneId, routeId) {
-    const response = await this.client.get(`/zones/${zoneId}/workers/routes/${routeId}`);
-    return response.result;
-  }
-  async createRoute(zoneId, pattern, script) {
-    const response = await this.client.post(`/zones/${zoneId}/workers/routes`, {
-      pattern,
-      script
-    });
-    return response.result;
-  }
-  async updateRoute(zoneId, routeId, pattern, script) {
-    const response = await this.client.put(`/zones/${zoneId}/workers/routes/${routeId}`, {
-      pattern,
-      script
-    });
-    return response.result;
-  }
-  async deleteRoute(zoneId, routeId) {
-    const response = await this.client.delete(`/zones/${zoneId}/workers/routes/${routeId}`);
-    return response.result;
-  }
-  async listDeployments(accountId, scriptName) {
-    return this.client.get(`/accounts/${accountId}/workers/scripts/${scriptName}/deployments`);
-  }
-  async deploy(accountId, scriptName, options) {
-    const body = {};
-    if (options?.strategy) {
-      body.strategy = options.strategy;
-    }
-    if (options?.annotations) {
-      body.annotations = options.annotations;
-    }
-    const response = await this.client.post(`/accounts/${accountId}/workers/scripts/${scriptName}/deployments`, Object.keys(body).length > 0 ? body : undefined);
-    return response.result;
-  }
-  async getSubdomain(accountId) {
-    const response = await this.client.get(`/accounts/${accountId}/workers/subdomain`);
-    return response.result;
-  }
-  async createSubdomain(accountId, subdomain) {
-    const response = await this.client.put(`/accounts/${accountId}/workers/subdomain`, { subdomain });
-    return response.result;
-  }
-  async startTail(accountId, scriptName) {
-    const response = await this.client.post(`/accounts/${accountId}/workers/scripts/${scriptName}/tails`);
-    return response.result;
-  }
-  async deleteTail(accountId, scriptName, tailId) {
-    await this.client.delete(`/accounts/${accountId}/workers/scripts/${scriptName}/tails/${tailId}`);
-  }
-}
-
-// src/api/pages.ts
-class PagesApi {
-  client;
-  constructor(client) {
-    this.client = client;
-  }
-  async list(accountId) {
-    return this.client.get(`/accounts/${accountId}/pages/projects`);
-  }
-  async get(accountId, projectName) {
-    const response = await this.client.get(`/accounts/${accountId}/pages/projects/${projectName}`);
-    return response.result;
-  }
-  async create(accountId, params) {
-    const response = await this.client.post(`/accounts/${accountId}/pages/projects`, params);
-    return response.result;
-  }
-  async update(accountId, projectName, params) {
-    const response = await this.client.patch(`/accounts/${accountId}/pages/projects/${projectName}`, params);
-    return response.result;
-  }
-  async delete(accountId, projectName) {
-    await this.client.delete(`/accounts/${accountId}/pages/projects/${projectName}`);
-  }
-  async listDeployments(accountId, projectName, params) {
-    return this.client.get(`/accounts/${accountId}/pages/projects/${projectName}/deployments`, params);
-  }
-  async getDeployment(accountId, projectName, deploymentId) {
-    const response = await this.client.get(`/accounts/${accountId}/pages/projects/${projectName}/deployments/${deploymentId}`);
-    return response.result;
-  }
-  async createDeployment(accountId, projectName, options) {
-    const formData = new FormData;
-    if (options?.branch) {
-      formData.append("branch", options.branch);
-    }
-    const response = await this.client.request(`/accounts/${accountId}/pages/projects/${projectName}/deployments`, {
-      method: "POST",
-      body: formData
-    });
-    return response.result;
-  }
-  async retryDeployment(accountId, projectName, deploymentId) {
-    const response = await this.client.post(`/accounts/${accountId}/pages/projects/${projectName}/deployments/${deploymentId}/retry`);
-    return response.result;
-  }
-  async rollback(accountId, projectName, deploymentId) {
-    const response = await this.client.post(`/accounts/${accountId}/pages/projects/${projectName}/deployments/${deploymentId}/rollback`);
-    return response.result;
-  }
-  async deleteDeployment(accountId, projectName, deploymentId) {
-    await this.client.delete(`/accounts/${accountId}/pages/projects/${projectName}/deployments/${deploymentId}`);
-  }
-  async getDeploymentLogs(accountId, projectName, deploymentId) {
-    const response = await this.client.get(`/accounts/${accountId}/pages/projects/${projectName}/deployments/${deploymentId}/history/logs`);
-    return response.result;
-  }
-  async listDomains(accountId, projectName) {
-    return this.client.get(`/accounts/${accountId}/pages/projects/${projectName}/domains`);
-  }
-  async addDomain(accountId, projectName, domain) {
-    const response = await this.client.post(`/accounts/${accountId}/pages/projects/${projectName}/domains`, { name: domain });
-    return response.result;
-  }
-  async deleteDomain(accountId, projectName, domainName) {
-    await this.client.delete(`/accounts/${accountId}/pages/projects/${projectName}/domains/${domainName}`);
-  }
-}
-
-// src/api/kv.ts
-class KVApi {
-  client;
-  constructor(client) {
-    this.client = client;
-  }
-  async listNamespaces(accountId, params) {
-    return this.client.get(`/accounts/${accountId}/storage/kv/namespaces`, params);
-  }
-  async getNamespace(accountId, namespaceId) {
-    const response = await this.client.get(`/accounts/${accountId}/storage/kv/namespaces/${namespaceId}`);
-    return response.result;
-  }
-  async createNamespace(accountId, params) {
-    const response = await this.client.post(`/accounts/${accountId}/storage/kv/namespaces`, params);
-    return response.result;
-  }
-  async renameNamespace(accountId, namespaceId, title) {
-    await this.client.put(`/accounts/${accountId}/storage/kv/namespaces/${namespaceId}`, { title });
-  }
-  async deleteNamespace(accountId, namespaceId) {
-    await this.client.delete(`/accounts/${accountId}/storage/kv/namespaces/${namespaceId}`);
-  }
-  async listKeys(accountId, namespaceId, params) {
-    return this.client.get(`/accounts/${accountId}/storage/kv/namespaces/${namespaceId}/keys`, params);
-  }
-  async getKeyMetadata(accountId, namespaceId, key) {
-    const response = await this.client.get(`/accounts/${accountId}/storage/kv/namespaces/${namespaceId}/metadata/${encodeURIComponent(key)}`);
-    return response.result;
-  }
-  async get(accountId, namespaceId, key) {
-    return this.client.request(`/accounts/${accountId}/storage/kv/namespaces/${namespaceId}/values/${encodeURIComponent(key)}`, { method: "GET" });
-  }
-  async put(accountId, namespaceId, params) {
-    const queryParams = {};
-    if (params.expiration) {
-      queryParams.expiration = params.expiration;
-    }
-    if (params.expiration_ttl) {
-      queryParams.expiration_ttl = params.expiration_ttl;
-    }
-    await this.client.request(`/accounts/${accountId}/storage/kv/namespaces/${namespaceId}/values/${encodeURIComponent(params.key)}`, {
-      method: "PUT",
-      body: params.value,
-      params: queryParams,
-      rawBody: true,
-      headers: {
-        "Content-Type": "text/plain"
-      }
-    });
-  }
-  async delete(accountId, namespaceId, key) {
-    await this.client.delete(`/accounts/${accountId}/storage/kv/namespaces/${namespaceId}/values/${encodeURIComponent(key)}`);
-  }
-  async bulkWrite(accountId, namespaceId, items) {
-    await this.client.put(`/accounts/${accountId}/storage/kv/namespaces/${namespaceId}/bulk`, items);
-  }
-  async bulkDelete(accountId, namespaceId, keys) {
-    await this.client.delete(`/accounts/${accountId}/storage/kv/namespaces/${namespaceId}/bulk`, { keys: keys.join(",") });
-  }
-}
-
-// src/api/r2.ts
-class R2Api {
-  client;
-  constructor(client) {
-    this.client = client;
-  }
-  async listBuckets(accountId, params) {
-    return this.client.get(`/accounts/${accountId}/r2/buckets`, params);
-  }
-  async getBucket(accountId, bucketName) {
-    const response = await this.client.get(`/accounts/${accountId}/r2/buckets/${bucketName}`);
-    return response.result;
-  }
-  async createBucket(accountId, params) {
-    const response = await this.client.post(`/accounts/${accountId}/r2/buckets`, params);
-    return response.result;
-  }
-  async deleteBucket(accountId, bucketName) {
-    await this.client.delete(`/accounts/${accountId}/r2/buckets/${bucketName}`);
-  }
-  async listObjects(accountId, bucketName, params) {
-    const queryParams = {};
-    if (params?.prefix)
-      queryParams.prefix = params.prefix;
-    if (params?.delimiter)
-      queryParams.delimiter = params.delimiter;
-    if (params?.cursor)
-      queryParams.cursor = params.cursor;
-    if (params?.limit)
-      queryParams.limit = params.limit;
-    const response = await this.client.get(`/accounts/${accountId}/r2/buckets/${bucketName}/objects`, queryParams);
-    return response.result;
-  }
-  async getObjectMetadata(accountId, bucketName, objectKey) {
-    const response = await this.client.get(`/accounts/${accountId}/r2/buckets/${bucketName}/objects/${encodeURIComponent(objectKey)}`);
-    return response.result;
-  }
-  async deleteObject(accountId, bucketName, objectKey) {
-    await this.client.delete(`/accounts/${accountId}/r2/buckets/${bucketName}/objects/${encodeURIComponent(objectKey)}`);
-  }
-  async getCors(accountId, bucketName) {
-    const response = await this.client.get(`/accounts/${accountId}/r2/buckets/${bucketName}/cors`);
-    return response.result;
-  }
-  async setCors(accountId, bucketName, rules) {
-    await this.client.put(`/accounts/${accountId}/r2/buckets/${bucketName}/cors`, { rules });
-  }
-  async deleteCors(accountId, bucketName) {
-    await this.client.delete(`/accounts/${accountId}/r2/buckets/${bucketName}/cors`);
-  }
-  async getLifecycle(accountId, bucketName) {
-    const response = await this.client.get(`/accounts/${accountId}/r2/buckets/${bucketName}/lifecycle`);
-    return response.result;
-  }
-  async setLifecycle(accountId, bucketName, rules) {
-    await this.client.put(`/accounts/${accountId}/r2/buckets/${bucketName}/lifecycle`, { rules });
-  }
-  async deleteLifecycle(accountId, bucketName) {
-    await this.client.delete(`/accounts/${accountId}/r2/buckets/${bucketName}/lifecycle`);
-  }
-  async getPublicAccess(accountId, bucketName) {
-    const response = await this.client.get(`/accounts/${accountId}/r2/buckets/${bucketName}/public`);
-    return response.result;
-  }
-  async enablePublicAccess(accountId, bucketName) {
-    await this.client.put(`/accounts/${accountId}/r2/buckets/${bucketName}/public`, { enabled: true });
-  }
-  async disablePublicAccess(accountId, bucketName) {
-    await this.client.put(`/accounts/${accountId}/r2/buckets/${bucketName}/public`, { enabled: false });
-  }
-}
-
-// src/api/cache.ts
-class CacheApi {
-  client;
-  constructor(client) {
-    this.client = client;
-  }
-  async purgeAll(zoneId) {
-    const response = await this.client.post(`/zones/${zoneId}/purge_cache`, { purge_everything: true });
-    return response.result;
-  }
-  async purgeByUrls(zoneId, urls) {
-    const response = await this.client.post(`/zones/${zoneId}/purge_cache`, { files: urls });
-    return response.result;
-  }
-  async purgeByTags(zoneId, tags) {
-    const response = await this.client.post(`/zones/${zoneId}/purge_cache`, { tags });
-    return response.result;
-  }
-  async purgeByHosts(zoneId, hosts) {
-    const response = await this.client.post(`/zones/${zoneId}/purge_cache`, { hosts });
-    return response.result;
-  }
-  async purgeByPrefixes(zoneId, prefixes) {
-    const response = await this.client.post(`/zones/${zoneId}/purge_cache`, { prefixes });
-    return response.result;
-  }
-  async purge(zoneId, params) {
-    const response = await this.client.post(`/zones/${zoneId}/purge_cache`, params);
-    return response.result;
-  }
-  async getCacheReserve(zoneId) {
-    const response = await this.client.get(`/zones/${zoneId}/cache/cache_reserve`);
-    return response.result;
-  }
-  async enableCacheReserve(zoneId) {
-    await this.client.patch(`/zones/${zoneId}/cache/cache_reserve`, { value: "on" });
-  }
-  async disableCacheReserve(zoneId) {
-    await this.client.patch(`/zones/${zoneId}/cache/cache_reserve`, { value: "off" });
-  }
-  async clearCacheReserve(zoneId) {
-    const response = await this.client.post(`/zones/${zoneId}/cache/cache_reserve_clear`);
-    return response.result;
-  }
-  async getTieredCache(zoneId) {
-    const response = await this.client.get(`/zones/${zoneId}/cache/tiered_cache_smart_topology_enable`);
-    return response.result;
-  }
-  async enableTieredCache(zoneId) {
-    await this.client.patch(`/zones/${zoneId}/cache/tiered_cache_smart_topology_enable`, { value: "on" });
-  }
-  async disableTieredCache(zoneId) {
-    await this.client.patch(`/zones/${zoneId}/cache/tiered_cache_smart_topology_enable`, { value: "off" });
-  }
-  async getRegionalTieredCache(zoneId) {
-    const response = await this.client.get(`/zones/${zoneId}/cache/regional_tiered_cache`);
-    return response.result;
-  }
-  async enableRegionalTieredCache(zoneId) {
-    await this.client.patch(`/zones/${zoneId}/cache/regional_tiered_cache`, { value: "on" });
-  }
-  async disableRegionalTieredCache(zoneId) {
-    await this.client.patch(`/zones/${zoneId}/cache/regional_tiered_cache`, { value: "off" });
-  }
-}
-
-// src/api/analytics.ts
-class AnalyticsApi {
-  client;
-  constructor(client) {
-    this.client = client;
-  }
-  parseRelativeDate(dateStr) {
-    if (!dateStr.startsWith("-")) {
-      return dateStr;
-    }
-    const match = dateStr.match(/^-(\d+)([dhm])$/);
-    if (!match) {
-      return dateStr;
-    }
-    const [, amount, unit] = match;
-    const now = new Date;
-    switch (unit) {
-      case "d":
-        now.setDate(now.getDate() - parseInt(amount));
-        break;
-      case "h":
-        now.setHours(now.getHours() - parseInt(amount));
-        break;
-      case "m":
-        now.setMinutes(now.getMinutes() - parseInt(amount));
-        break;
-    }
-    return now.toISOString().split("T")[0];
-  }
-  async getDashboard(zoneId, params) {
-    const since = params?.since ? this.parseRelativeDate(params.since) : this.parseRelativeDate("-7d");
-    const until = params?.until ? this.parseRelativeDate(params.until) : new Date().toISOString().split("T")[0];
-    const variables = {
-      zoneTag: zoneId,
-      since,
-      until
-    };
-    try {
-      return await this.getDashboardFull(variables);
-    } catch (err) {
-      const errorMsg = err instanceof Error ? err.message : String(err);
-      if (errorMsg.includes("Cannot query field") || errorMsg.includes("Unknown field")) {
-        return await this.getDashboardSimple(variables);
-      }
-      throw err;
-    }
-  }
-  async getDashboardFull(variables) {
-    const query = `
-      query GetZoneAnalytics($zoneTag: String!, $since: Date!, $until: Date!) {
-        viewer {
-          zones(filter: { zoneTag: $zoneTag }) {
-            httpRequests1dGroups(
-              limit: 100
-              filter: { date_geq: $since, date_leq: $until }
-              orderBy: [date_ASC]
-            ) {
-              dimensions {
-                date
-              }
-              sum {
-                requests
-                bytes
-                threats
-                cachedRequests
-                cachedBytes
-                encryptedRequests
-                encryptedBytes
-                pageViews
-              }
-              uniq {
-                uniques
-              }
-            }
-          }
-        }
-      }
-    `;
-    const response = await this.graphqlQuery(query, variables);
-    if (response.errors && response.errors.length > 0) {
-      throw new Error(`GraphQL error: ${response.errors.map((e) => e.message).join(", ")}`);
-    }
-    return this.transformGraphQLResponse(response, true);
-  }
-  async getDashboardSimple(variables) {
-    const query = `
-      query GetZoneAnalytics($zoneTag: String!, $since: Date!, $until: Date!) {
-        viewer {
-          zones(filter: { zoneTag: $zoneTag }) {
-            httpRequests1dGroups(
-              limit: 100
-              filter: { date_geq: $since, date_leq: $until }
-              orderBy: [date_ASC]
-            ) {
-              dimensions {
-                date
-              }
-              sum {
-                requests
-                bytes
-                threats
-                cachedRequests
-                cachedBytes
-                pageViews
-              }
-              uniq {
-                uniques
-              }
-            }
-          }
-        }
-      }
-    `;
-    const response = await this.graphqlQuery(query, variables);
-    if (response.errors && response.errors.length > 0) {
-      throw new Error(`GraphQL error: ${response.errors.map((e) => e.message).join(", ")}`);
-    }
-    return this.transformGraphQLResponse(response, false);
-  }
-  transformGraphQLResponse(response, hasEncryptedFields) {
-    const zones = response.data?.viewer?.zones;
-    if (!zones || zones.length === 0 || !zones[0].httpRequests1dGroups) {
-      return this.createEmptyAnalytics();
-    }
-    const groups = zones[0].httpRequests1dGroups;
-    const totals = groups.reduce((acc, group) => {
-      acc.requests.all += group.sum.requests || 0;
-      acc.requests.cached += group.sum.cachedRequests || 0;
-      acc.requests.uncached += (group.sum.requests || 0) - (group.sum.cachedRequests || 0);
-      const encryptedRequests = hasEncryptedFields ? group.sum.encryptedRequests || 0 : 0;
-      const encryptedBytes = hasEncryptedFields ? group.sum.encryptedBytes || 0 : 0;
-      acc.requests.ssl.encrypted += encryptedRequests;
-      acc.requests.ssl.unencrypted += (group.sum.requests || 0) - encryptedRequests;
-      acc.bandwidth.all += group.sum.bytes || 0;
-      acc.bandwidth.cached += group.sum.cachedBytes || 0;
-      acc.bandwidth.uncached += (group.sum.bytes || 0) - (group.sum.cachedBytes || 0);
-      acc.bandwidth.ssl.encrypted += encryptedBytes;
-      acc.bandwidth.ssl.unencrypted += (group.sum.bytes || 0) - encryptedBytes;
-      acc.threats.all += group.sum.threats || 0;
-      acc.pageviews.all += group.sum.pageViews || 0;
-      acc.uniques.all += group.uniq?.uniques || 0;
-      return acc;
-    }, this.createEmptyTotals());
-    const timeseries = groups.map((group) => {
-      const encryptedRequests = hasEncryptedFields ? group.sum.encryptedRequests || 0 : 0;
-      const encryptedBytes = hasEncryptedFields ? group.sum.encryptedBytes || 0 : 0;
-      return {
-        since: `${group.dimensions.date}T00:00:00Z`,
-        until: `${group.dimensions.date}T23:59:59Z`,
-        requests: {
-          all: group.sum.requests || 0,
-          cached: group.sum.cachedRequests || 0,
-          uncached: (group.sum.requests || 0) - (group.sum.cachedRequests || 0),
-          content_type: {},
-          country: {},
-          ssl: {
-            encrypted: encryptedRequests,
-            unencrypted: (group.sum.requests || 0) - encryptedRequests
-          },
-          http_status: {}
-        },
-        bandwidth: {
-          all: group.sum.bytes || 0,
-          cached: group.sum.cachedBytes || 0,
-          uncached: (group.sum.bytes || 0) - (group.sum.cachedBytes || 0),
-          content_type: {},
-          country: {},
-          ssl: {
-            encrypted: encryptedBytes,
-            unencrypted: (group.sum.bytes || 0) - encryptedBytes
-          }
-        },
-        threats: {
-          all: group.sum.threats || 0,
-          country: {},
-          type: {}
-        },
-        pageviews: {
-          all: group.sum.pageViews || 0,
-          search_engines: {}
-        },
-        uniques: {
-          all: group.uniq?.uniques || 0
-        }
-      };
-    });
-    return {
-      totals,
-      timeseries
-    };
-  }
-  createEmptyTotals() {
-    return {
-      requests: {
-        all: 0,
-        cached: 0,
-        uncached: 0,
-        content_type: {},
-        country: {},
-        ssl: { encrypted: 0, unencrypted: 0 },
-        http_status: {}
-      },
-      bandwidth: {
-        all: 0,
-        cached: 0,
-        uncached: 0,
-        content_type: {},
-        country: {},
-        ssl: { encrypted: 0, unencrypted: 0 }
-      },
-      threats: {
-        all: 0,
-        country: {},
-        type: {}
-      },
-      pageviews: {
-        all: 0,
-        search_engines: {}
-      },
-      uniques: {
-        all: 0
-      }
-    };
-  }
-  createEmptyAnalytics() {
-    return {
-      totals: this.createEmptyTotals(),
-      timeseries: []
-    };
-  }
-  async getColos(zoneId, params) {
-    const queryParams = {};
-    if (params?.since)
-      queryParams.since = params.since;
-    if (params?.until)
-      queryParams.until = params.until;
-    if (params?.continuous !== undefined)
-      queryParams.continuous = params.continuous;
-    const response = await this.client.get(`/zones/${zoneId}/analytics/colos`, queryParams);
-    return response.result;
-  }
-  async getDnsAnalytics(zoneId, params) {
-    const queryParams = {};
-    if (params?.since)
-      queryParams.since = params.since;
-    if (params?.until)
-      queryParams.until = params.until;
-    if (params?.dimensions)
-      queryParams.dimensions = params.dimensions.join(",");
-    if (params?.metrics)
-      queryParams.metrics = params.metrics.join(",");
-    if (params?.filters)
-      queryParams.filters = params.filters;
-    if (params?.sort)
-      queryParams.sort = params.sort.join(",");
-    if (params?.limit)
-      queryParams.limit = params.limit;
-    const response = await this.client.get(`/zones/${zoneId}/dns_analytics/report`, queryParams);
-    return response.result;
-  }
-  async getDnsAnalyticsByTime(zoneId, params) {
-    const queryParams = {};
-    if (params?.since)
-      queryParams.since = params.since;
-    if (params?.until)
-      queryParams.until = params.until;
-    if (params?.dimensions)
-      queryParams.dimensions = params.dimensions.join(",");
-    if (params?.metrics)
-      queryParams.metrics = params.metrics.join(",");
-    if (params?.filters)
-      queryParams.filters = params.filters;
-    if (params?.sort)
-      queryParams.sort = params.sort.join(",");
-    if (params?.limit)
-      queryParams.limit = params.limit;
-    if (params?.time_delta)
-      queryParams.time_delta = params.time_delta;
-    const response = await this.client.get(`/zones/${zoneId}/dns_analytics/report/bytime`, queryParams);
-    return response.result;
-  }
-  async getWorkersAnalytics(accountId, params) {
-    const queryParams = {};
-    if (params?.since)
-      queryParams.since = params.since;
-    if (params?.until)
-      queryParams.until = params.until;
-    if (params?.script_name)
-      queryParams.script_name = params.script_name;
-    const response = await this.client.get(`/accounts/${accountId}/workers/analytics/aggregate`, queryParams);
-    return response.result;
-  }
-  async listWebAnalyticsSites(accountId, params) {
-    return this.client.get(`/accounts/${accountId}/rum/site_info/list`, params);
-  }
-  async getWebAnalyticsSite(accountId, siteTag) {
-    const response = await this.client.get(`/accounts/${accountId}/rum/site_info/${siteTag}`);
-    return response.result;
-  }
-  async graphqlQuery(query, variables) {
-    const response = await this.client.request("/graphql", {
-      method: "POST",
-      body: { query, variables },
-      rawResponse: true
-    });
-    return response;
-  }
-}
-
-// src/api/firewall.ts
-class FirewallApi {
-  client;
-  constructor(client) {
-    this.client = client;
-  }
-  async listRules(zoneId, params) {
-    return this.client.get(`/zones/${zoneId}/firewall/rules`, params);
-  }
-  async getRule(zoneId, ruleId) {
-    const response = await this.client.get(`/zones/${zoneId}/firewall/rules/${ruleId}`);
-    return response.result;
-  }
-  async createRules(zoneId, rules) {
-    const response = await this.client.post(`/zones/${zoneId}/firewall/rules`, rules);
-    return response.result;
-  }
-  async createRule(zoneId, rule) {
-    const rules = await this.createRules(zoneId, [rule]);
-    return rules[0];
-  }
-  async updateRule(zoneId, ruleId, rule) {
-    const response = await this.client.put(`/zones/${zoneId}/firewall/rules/${ruleId}`, { id: ruleId, ...rule });
-    return response.result;
-  }
-  async deleteRule(zoneId, ruleId) {
-    await this.client.delete(`/zones/${zoneId}/firewall/rules/${ruleId}`);
-  }
-  async deleteRulesByFilter(zoneId, filterId) {
-    await this.client.delete(`/zones/${zoneId}/firewall/rules`, { id: filterId });
-  }
-  async listFilters(zoneId, params) {
-    return this.client.get(`/zones/${zoneId}/filters`, params);
-  }
-  async getFilter(zoneId, filterId) {
-    const response = await this.client.get(`/zones/${zoneId}/filters/${filterId}`);
-    return response.result;
-  }
-  async createFilters(zoneId, filters) {
-    const response = await this.client.post(`/zones/${zoneId}/filters`, filters);
-    return response.result;
-  }
-  async createFilter(zoneId, filter) {
-    const filters = await this.createFilters(zoneId, [filter]);
-    return filters[0];
-  }
-  async updateFilter(zoneId, filterId, filter) {
-    const response = await this.client.put(`/zones/${zoneId}/filters/${filterId}`, { id: filterId, ...filter });
-    return response.result;
-  }
-  async deleteFilter(zoneId, filterId) {
-    await this.client.delete(`/zones/${zoneId}/filters/${filterId}`);
-  }
-  async listWafPackages(zoneId, params) {
-    return this.client.get(`/zones/${zoneId}/firewall/waf/packages`, params);
-  }
-  async listWafGroups(zoneId, packageId, params) {
-    return this.client.get(`/zones/${zoneId}/firewall/waf/packages/${packageId}/groups`, params);
-  }
-  async listWafRules(zoneId, packageId, params) {
-    return this.client.get(`/zones/${zoneId}/firewall/waf/packages/${packageId}/rules`, params);
-  }
-  async getWafRule(zoneId, packageId, ruleId) {
-    const response = await this.client.get(`/zones/${zoneId}/firewall/waf/packages/${packageId}/rules/${ruleId}`);
-    return response.result;
-  }
-  async updateWafRuleMode(zoneId, packageId, ruleId, mode) {
-    const response = await this.client.patch(`/zones/${zoneId}/firewall/waf/packages/${packageId}/rules/${ruleId}`, { mode });
-    return response.result;
-  }
-  async listAccessRules(zoneId, params) {
-    return this.client.get(`/zones/${zoneId}/firewall/access_rules/rules`, params);
-  }
-  async createAccessRule(zoneId, rule) {
-    const response = await this.client.post(`/zones/${zoneId}/firewall/access_rules/rules`, rule);
-    return response.result;
-  }
-  async updateAccessRule(zoneId, ruleId, rule) {
-    const response = await this.client.patch(`/zones/${zoneId}/firewall/access_rules/rules/${ruleId}`, rule);
-    return response.result;
-  }
-  async deleteAccessRule(zoneId, ruleId) {
-    const response = await this.client.delete(`/zones/${zoneId}/firewall/access_rules/rules/${ruleId}`);
-    return response.result;
-  }
-}
-
-// src/api/ssl.ts
-class SSLApi {
-  client;
-  constructor(client) {
-    this.client = client;
-  }
-  async getMode(zoneId) {
-    const response = await this.client.get(`/zones/${zoneId}/settings/ssl`);
-    return response.result;
-  }
-  async setMode(zoneId, mode) {
-    const response = await this.client.patch(`/zones/${zoneId}/settings/ssl`, { value: mode });
-    return response.result;
-  }
-  async getAlwaysUseHttps(zoneId) {
-    const response = await this.client.get(`/zones/${zoneId}/settings/always_use_https`);
-    return response.result;
-  }
-  async enableAlwaysUseHttps(zoneId) {
-    const response = await this.client.patch(`/zones/${zoneId}/settings/always_use_https`, { value: "on" });
-    return response.result;
-  }
-  async disableAlwaysUseHttps(zoneId) {
-    const response = await this.client.patch(`/zones/${zoneId}/settings/always_use_https`, { value: "off" });
-    return response.result;
-  }
-  async getAutomaticHttpsRewrites(zoneId) {
-    const response = await this.client.get(`/zones/${zoneId}/settings/automatic_https_rewrites`);
-    return response.result;
-  }
-  async enableAutomaticHttpsRewrites(zoneId) {
-    const response = await this.client.patch(`/zones/${zoneId}/settings/automatic_https_rewrites`, { value: "on" });
-    return response.result;
-  }
-  async disableAutomaticHttpsRewrites(zoneId) {
-    const response = await this.client.patch(`/zones/${zoneId}/settings/automatic_https_rewrites`, { value: "off" });
-    return response.result;
-  }
-  async getMinTlsVersion(zoneId) {
-    const response = await this.client.get(`/zones/${zoneId}/settings/min_tls_version`);
-    return response.result;
-  }
-  async setMinTlsVersion(zoneId, version) {
-    const response = await this.client.patch(`/zones/${zoneId}/settings/min_tls_version`, { value: version });
-    return response.result;
-  }
-  async getOpportunisticEncryption(zoneId) {
-    const response = await this.client.get(`/zones/${zoneId}/settings/opportunistic_encryption`);
-    return response.result;
-  }
-  async enableOpportunisticEncryption(zoneId) {
-    const response = await this.client.patch(`/zones/${zoneId}/settings/opportunistic_encryption`, { value: "on" });
-    return response.result;
-  }
-  async disableOpportunisticEncryption(zoneId) {
-    const response = await this.client.patch(`/zones/${zoneId}/settings/opportunistic_encryption`, { value: "off" });
-    return response.result;
-  }
-  async getUniversalSsl(zoneId) {
-    const response = await this.client.get(`/zones/${zoneId}/ssl/universal/settings`);
-    return response.result;
-  }
-  async enableUniversalSsl(zoneId) {
-    await this.client.patch(`/zones/${zoneId}/ssl/universal/settings`, { enabled: true });
-  }
-  async disableUniversalSsl(zoneId) {
-    await this.client.patch(`/zones/${zoneId}/ssl/universal/settings`, { enabled: false });
-  }
-  async listCertificates(zoneId, params) {
-    return this.client.get(`/zones/${zoneId}/custom_certificates`, params);
-  }
-  async getCertificate(zoneId, certificateId) {
-    const response = await this.client.get(`/zones/${zoneId}/custom_certificates/${certificateId}`);
-    return response.result;
-  }
-  async uploadCertificate(zoneId, params) {
-    const response = await this.client.post(`/zones/${zoneId}/custom_certificates`, params);
-    return response.result;
-  }
-  async updateCertificate(zoneId, certificateId, params) {
-    const response = await this.client.patch(`/zones/${zoneId}/custom_certificates/${certificateId}`, params);
-    return response.result;
-  }
-  async deleteCertificate(zoneId, certificateId) {
-    const response = await this.client.delete(`/zones/${zoneId}/custom_certificates/${certificateId}`);
-    return response.result;
-  }
-  async prioritizeCertificates(zoneId, certificates) {
-    const response = await this.client.put(`/zones/${zoneId}/custom_certificates/prioritize`, { certificates });
-    return response.result;
-  }
-  async getVerification(zoneId) {
-    const response = await this.client.get(`/zones/${zoneId}/ssl/verification`);
-    return response.result;
-  }
-  async editVerification(zoneId, certPackId, method) {
-    const response = await this.client.patch(`/zones/${zoneId}/ssl/verification/${certPackId}`, { validation_method: method });
-    return response.result;
-  }
-  async listOriginCertificates(zoneId) {
-    return this.client.get("/certificates", { zone_id: zoneId });
-  }
-  async getOriginCertificate(certificateId) {
-    const response = await this.client.get(`/certificates/${certificateId}`);
-    return response.result;
-  }
-  async createOriginCertificate(params) {
-    const response = await this.client.post("/certificates", params);
-    return response.result;
-  }
-  async revokeOriginCertificate(certificateId) {
-    const response = await this.client.delete(`/certificates/${certificateId}`);
-    return response.result;
-  }
-  async listClientCertificates(zoneId, params) {
-    return this.client.get(`/zones/${zoneId}/client_certificates`, params);
-  }
-  async createClientCertificate(zoneId, params) {
-    const response = await this.client.post(`/zones/${zoneId}/client_certificates`, params);
-    return response.result;
-  }
-  async revokeClientCertificate(zoneId, certificateId) {
-    const response = await this.client.delete(`/zones/${zoneId}/client_certificates/${certificateId}`);
-    return response.result;
-  }
-}
-
-// src/api/accounts.ts
-class AccountsApi {
-  client;
-  constructor(client) {
-    this.client = client;
-  }
-  async list(params) {
-    return this.client.get("/accounts", params);
-  }
-  async get(accountId) {
-    const response = await this.client.get(`/accounts/${accountId}`);
-    return response.result;
-  }
-  async update(accountId, settings) {
-    const response = await this.client.patch(`/accounts/${accountId}`, settings);
-    return response.result;
-  }
-  async listMembers(accountId, params) {
-    return this.client.get(`/accounts/${accountId}/members`, params);
-  }
-  async getMember(accountId, memberId) {
-    const response = await this.client.get(`/accounts/${accountId}/members/${memberId}`);
-    return response.result;
-  }
-  async addMember(accountId, params) {
-    const response = await this.client.post(`/accounts/${accountId}/members`, params);
-    return response.result;
-  }
-  async updateMember(accountId, memberId, params) {
-    const response = await this.client.put(`/accounts/${accountId}/members/${memberId}`, params);
-    return response.result;
-  }
-  async removeMember(accountId, memberId) {
-    const response = await this.client.delete(`/accounts/${accountId}/members/${memberId}`);
-    return response.result;
-  }
-  async listRoles(accountId) {
-    return this.client.get(`/accounts/${accountId}/roles`);
-  }
-  async getRole(accountId, roleId) {
-    const response = await this.client.get(`/accounts/${accountId}/roles/${roleId}`);
-    return response.result;
-  }
-  async listSubscriptions(accountId) {
-    return this.client.get(`/accounts/${accountId}/subscriptions`);
-  }
-  async verifyToken() {
-    const response = await this.client.get("/user/tokens/verify");
-    return response.result;
-  }
-  async getUser() {
-    const response = await this.client.get("/user");
-    return response.result;
-  }
-}
-
-// src/api/bulk.ts
-class FilterParser {
-  static parse(filterString) {
-    const filter = {};
-    if (!filterString || filterString.trim() === "") {
-      return filter;
-    }
-    const conditions = filterString.split(/\s+(?:and\s+)?|&/i).filter(Boolean);
-    for (const condition of conditions) {
-      const match = condition.match(/^(\w+)(=|!=|~|!~)(.+)$/);
-      if (!match)
-        continue;
-      const [, field, operator, value] = match;
-      switch (field?.toLowerCase()) {
-        case "type":
-          if (value?.includes(",")) {
-            filter.type = value.split(",").map((v) => v.trim().toUpperCase());
-          } else {
-            filter.type = value?.toUpperCase();
-          }
-          break;
-        case "name":
-          filter.name = value;
-          break;
-        case "content":
-          filter.content = value;
-          break;
-        case "proxied":
-          filter.proxied = value?.toLowerCase() === "true";
-          break;
-        case "ttl":
-          filter.ttl = parseInt(value || "0", 10);
-          break;
-        case "comment":
-          filter.comment = value;
-          break;
-      }
-    }
-    return filter;
-  }
-  static matches(record, filter) {
-    if (filter.type) {
-      const types = Array.isArray(filter.type) ? filter.type : [filter.type];
-      if (!types.includes(record.type)) {
-        return false;
-      }
-    }
-    if (filter.name) {
-      if (!this.matchGlob(record.name, filter.name)) {
-        return false;
-      }
-    }
-    if (filter.content) {
-      if (!record.content.includes(filter.content)) {
-        return false;
-      }
-    }
-    if (filter.proxied !== undefined) {
-      if (record.proxied !== filter.proxied) {
-        return false;
-      }
-    }
-    if (filter.ttl !== undefined) {
-      if (record.ttl !== filter.ttl) {
-        return false;
-      }
-    }
-    if (filter.comment) {
-      if (!record.comment?.includes(filter.comment)) {
-        return false;
-      }
-    }
-    return true;
-  }
-  static matchGlob(str, pattern) {
-    const regex = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*").replace(/\?/g, ".");
-    return new RegExp(`^${regex}$`, "i").test(str);
-  }
-}
-
-class BulkApi {
-  client;
-  dns;
-  firewall;
-  workers;
-  constructor(client) {
-    this.client = client;
-    this.dns = new DNSApi(client);
-    this.firewall = new FirewallApi(client);
-    this.workers = new WorkersApi(client);
-  }
-  async getAllDNSRecords(zoneId, filter) {
-    const allRecords = [];
-    let page = 1;
-    const perPage = 100;
-    let hasMore = true;
-    while (hasMore) {
-      const response = await this.dns.list(zoneId, { page, per_page: perPage });
-      const records = response.result || [];
-      const filtered = filter ? records.filter((r) => FilterParser.matches(r, filter)) : records;
-      allRecords.push(...filtered);
-      const resultInfo = response.result_info;
-      if (resultInfo && resultInfo.page < resultInfo.total_pages) {
-        page++;
-      } else {
-        hasMore = false;
-      }
-    }
-    return allRecords;
-  }
-  async previewDNSRecords(zoneId, filter) {
-    return this.getAllDNSRecords(zoneId, filter);
-  }
-  async bulkCreateDNS(zoneId, records, options = {}) {
-    const {
-      concurrency = 5,
-      dryRun = false,
-      onProgress,
-      continueOnError = false,
-      delayMs = 0
-    } = options;
-    const results = [];
-    const errors = [];
-    let completed = 0;
-    let succeeded = 0;
-    let failed = 0;
-    const reportProgress = () => {
-      onProgress?.({
-        total: records.length,
-        completed,
-        succeeded,
-        failed,
-        errors
-      });
-    };
-    for (let i = 0;i < records.length; i += concurrency) {
-      const batch = records.slice(i, i + concurrency);
-      const batchPromises = batch.map(async (record) => {
-        try {
-          if (dryRun) {
-            results.push({
-              id: "dry-run-id",
-              zone_id: zoneId,
-              zone_name: "",
-              name: record.name,
-              type: record.type,
-              content: record.content,
-              proxiable: true,
-              proxied: record.proxied ?? false,
-              ttl: record.ttl ?? 1,
-              locked: false,
-              created_on: new Date().toISOString(),
-              modified_on: new Date().toISOString()
-            });
-            succeeded++;
-          } else {
-            const result = await this.dns.create(zoneId, {
-              type: record.type,
-              name: record.name,
-              content: record.content,
-              ttl: record.ttl,
-              priority: record.priority,
-              proxied: record.proxied,
-              comment: record.comment
-            });
-            results.push(result);
-            succeeded++;
-          }
-        } catch (err) {
-          failed++;
-          errors.push({
-            item: `${record.type} ${record.name} -> ${record.content}`,
-            error: err instanceof Error ? err.message : String(err)
-          });
-          if (!continueOnError) {
-            throw err;
-          }
-        } finally {
-          completed++;
-          reportProgress();
-        }
-      });
-      try {
-        await Promise.all(batchPromises);
-      } catch {
-        if (!continueOnError)
-          break;
-      }
-      if (delayMs > 0 && i + concurrency < records.length) {
-        await this.delay(delayMs);
-      }
-    }
-    return {
-      success: failed === 0,
-      total: records.length,
-      succeeded,
-      failed,
-      results,
-      errors,
-      dryRun
-    };
-  }
-  async bulkUpdateDNS(zoneId, filter, updates, options = {}) {
-    const {
-      concurrency = 5,
-      dryRun = false,
-      onProgress,
-      continueOnError = false,
-      delayMs = 0
-    } = options;
-    const matchingRecords = await this.getAllDNSRecords(zoneId, filter);
-    const results = [];
-    const errors = [];
-    let completed = 0;
-    let succeeded = 0;
-    let failed = 0;
-    const reportProgress = () => {
-      onProgress?.({
-        total: matchingRecords.length,
-        completed,
-        succeeded,
-        failed,
-        current: matchingRecords[completed]?.name,
-        errors
-      });
-    };
-    for (let i = 0;i < matchingRecords.length; i += concurrency) {
-      const batch = matchingRecords.slice(i, i + concurrency);
-      const batchPromises = batch.map(async (record) => {
-        try {
-          if (dryRun) {
-            results.push({
-              ...record,
-              ...updates,
-              modified_on: new Date().toISOString()
-            });
-            succeeded++;
-          } else {
-            const updateParams = {
-              type: updates.type ?? record.type,
-              name: updates.name ?? record.name,
-              content: updates.content ?? record.content,
-              ttl: updates.ttl ?? record.ttl,
-              proxied: updates.proxied ?? record.proxied,
-              priority: updates.priority ?? record.priority,
-              comment: updates.comment ?? record.comment
-            };
-            const result = await this.dns.update(zoneId, record.id, updateParams);
-            results.push(result);
-            succeeded++;
-          }
-        } catch (err) {
-          failed++;
-          errors.push({
-            item: `${record.type} ${record.name} (${record.id})`,
-            error: err instanceof Error ? err.message : String(err)
-          });
-          if (!continueOnError) {
-            throw err;
-          }
-        } finally {
-          completed++;
-          reportProgress();
-        }
-      });
-      try {
-        await Promise.all(batchPromises);
-      } catch {
-        if (!continueOnError)
-          break;
-      }
-      if (delayMs > 0 && i + concurrency < matchingRecords.length) {
-        await this.delay(delayMs);
-      }
-    }
-    return {
-      success: failed === 0,
-      total: matchingRecords.length,
-      succeeded,
-      failed,
-      results,
-      errors,
-      dryRun
-    };
-  }
-  async bulkDeleteDNS(zoneId, filter, options = {}) {
-    const {
-      concurrency = 5,
-      dryRun = false,
-      onProgress,
-      continueOnError = false,
-      delayMs = 0
-    } = options;
-    const matchingRecords = await this.getAllDNSRecords(zoneId, filter);
-    const results = [];
-    const errors = [];
-    let completed = 0;
-    let succeeded = 0;
-    let failed = 0;
-    const reportProgress = () => {
-      onProgress?.({
-        total: matchingRecords.length,
-        completed,
-        succeeded,
-        failed,
-        current: matchingRecords[completed]?.name,
-        errors
-      });
-    };
-    for (let i = 0;i < matchingRecords.length; i += concurrency) {
-      const batch = matchingRecords.slice(i, i + concurrency);
-      const batchPromises = batch.map(async (record) => {
-        try {
-          if (dryRun) {
-            results.push({ id: record.id, name: record.name });
-            succeeded++;
-          } else {
-            await this.dns.delete(zoneId, record.id);
-            results.push({ id: record.id, name: record.name });
-            succeeded++;
-          }
-        } catch (err) {
-          failed++;
-          errors.push({
-            item: `${record.type} ${record.name} (${record.id})`,
-            error: err instanceof Error ? err.message : String(err)
-          });
-          if (!continueOnError) {
-            throw err;
-          }
-        } finally {
-          completed++;
-          reportProgress();
-        }
-      });
-      try {
-        await Promise.all(batchPromises);
-      } catch {
-        if (!continueOnError)
-          break;
-      }
-      if (delayMs > 0 && i + concurrency < matchingRecords.length) {
-        await this.delay(delayMs);
-      }
-    }
-    return {
-      success: failed === 0,
-      total: matchingRecords.length,
-      succeeded,
-      failed,
-      results,
-      errors,
-      dryRun
-    };
-  }
-  async exportDNS(zoneId, options) {
-    const records = await this.getAllDNSRecords(zoneId, options.filter);
-    switch (options.format) {
-      case "json":
-        return this.exportDNSToJSON(records, options.includeIds);
-      case "csv":
-        return this.exportDNSToCSV(records, options.includeIds);
-      case "bind":
-        return this.dns.export(zoneId);
-      default:
-        throw new Error(`Unknown export format: ${options.format}`);
-    }
-  }
-  async importDNS(zoneId, data, format, options = {}) {
-    let records;
-    if (format === "json") {
-      records = this.parseDNSFromJSON(data);
-    } else {
-      records = this.parseDNSFromCSV(data);
-    }
-    return this.bulkCreateDNS(zoneId, records, options);
-  }
-  async getAllFirewallRules(zoneId) {
-    const allRules = [];
-    let page = 1;
-    const perPage = 100;
-    let hasMore = true;
-    while (hasMore) {
-      const response = await this.firewall.listRules(zoneId, { page, per_page: perPage });
-      const rules = response.result || [];
-      allRules.push(...rules);
-      const resultInfo = response.result_info;
-      if (resultInfo && resultInfo.page < resultInfo.total_pages) {
-        page++;
-      } else {
-        hasMore = false;
-      }
-    }
-    return allRules;
-  }
-  async bulkCreateFirewallRules(zoneId, rules, options = {}) {
-    const {
-      dryRun = false,
-      onProgress
-    } = options;
-    const errors = [];
-    let results = [];
-    onProgress?.({
-      total: rules.length,
-      completed: 0,
-      succeeded: 0,
-      failed: 0,
-      errors
-    });
-    if (dryRun) {
-      results = rules.map((rule, i) => ({
-        id: `dry-run-${i}`,
-        paused: rule.paused ?? false,
-        description: rule.description ?? "",
-        action: rule.action,
-        filter: {
-          id: `filter-${i}`,
-          expression: rule.filter.expression,
-          paused: false,
-          description: rule.filter.description
-        },
-        created_on: new Date().toISOString(),
-        modified_on: new Date().toISOString()
-      }));
-      onProgress?.({
-        total: rules.length,
-        completed: rules.length,
-        succeeded: rules.length,
-        failed: 0,
-        errors
-      });
-      return {
-        success: true,
-        total: rules.length,
-        succeeded: rules.length,
-        failed: 0,
-        results,
-        errors,
-        dryRun: true
-      };
-    }
-    try {
-      results = await this.firewall.createRules(zoneId, rules);
-      onProgress?.({
-        total: rules.length,
-        completed: rules.length,
-        succeeded: results.length,
-        failed: rules.length - results.length,
-        errors
-      });
-      return {
-        success: true,
-        total: rules.length,
-        succeeded: results.length,
-        failed: 0,
-        results,
-        errors,
-        dryRun: false
-      };
-    } catch (err) {
-      errors.push({
-        item: "Bulk firewall rules creation",
-        error: err instanceof Error ? err.message : String(err)
-      });
-      return {
-        success: false,
-        total: rules.length,
-        succeeded: 0,
-        failed: rules.length,
-        results: [],
-        errors,
-        dryRun: false
-      };
-    }
-  }
-  async bulkDeleteFirewallRules(zoneId, ruleIds, options = {}) {
-    const {
-      concurrency = 5,
-      dryRun = false,
-      onProgress,
-      continueOnError = false,
-      delayMs = 0
-    } = options;
-    const results = [];
-    const errors = [];
-    let completed = 0;
-    let succeeded = 0;
-    let failed = 0;
-    const reportProgress = () => {
-      onProgress?.({
-        total: ruleIds.length,
-        completed,
-        succeeded,
-        failed,
-        errors
-      });
-    };
-    for (let i = 0;i < ruleIds.length; i += concurrency) {
-      const batch = ruleIds.slice(i, i + concurrency);
-      const batchPromises = batch.map(async (ruleId) => {
-        try {
-          if (dryRun) {
-            results.push({ id: ruleId });
-            succeeded++;
-          } else {
-            await this.firewall.deleteRule(zoneId, ruleId);
-            results.push({ id: ruleId });
-            succeeded++;
-          }
-        } catch (err) {
-          failed++;
-          errors.push({
-            item: `Rule ${ruleId}`,
-            error: err instanceof Error ? err.message : String(err)
-          });
-          if (!continueOnError) {
-            throw err;
-          }
-        } finally {
-          completed++;
-          reportProgress();
-        }
-      });
-      try {
-        await Promise.all(batchPromises);
-      } catch {
-        if (!continueOnError)
-          break;
-      }
-      if (delayMs > 0 && i + concurrency < ruleIds.length) {
-        await this.delay(delayMs);
-      }
-    }
-    return {
-      success: failed === 0,
-      total: ruleIds.length,
-      succeeded,
-      failed,
-      results,
-      errors,
-      dryRun
-    };
-  }
-  async bulkDeployWorkers(accountId, workers, options = {}) {
-    const {
-      concurrency = 3,
-      dryRun = false,
-      onProgress,
-      continueOnError = false,
-      delayMs = 1000
-    } = options;
-    const results = [];
-    const errors = [];
-    let completed = 0;
-    let succeeded = 0;
-    let failed = 0;
-    const reportProgress = () => {
-      onProgress?.({
-        total: workers.length,
-        completed,
-        succeeded,
-        failed,
-        current: workers[completed]?.name,
-        errors
-      });
-    };
-    for (let i = 0;i < workers.length; i += concurrency) {
-      const batch = workers.slice(i, i + concurrency);
-      const batchPromises = batch.map(async (worker) => {
-        try {
-          if (dryRun) {
-            results.push({ name: worker.name, id: "dry-run-id" });
-            succeeded++;
-          } else {
-            const result = await this.workers.create(accountId, worker.name, {
-              script: worker.script,
-              compatibility_date: worker.compatibility_date
-            });
-            results.push({ name: worker.name, id: result.id });
-            succeeded++;
-          }
-        } catch (err) {
-          failed++;
-          errors.push({
-            item: `Worker: ${worker.name}`,
-            error: err instanceof Error ? err.message : String(err)
-          });
-          if (!continueOnError) {
-            throw err;
-          }
-        } finally {
-          completed++;
-          reportProgress();
-        }
-      });
-      try {
-        await Promise.all(batchPromises);
-      } catch {
-        if (!continueOnError)
-          break;
-      }
-      if (delayMs > 0 && i + concurrency < workers.length) {
-        await this.delay(delayMs);
-      }
-    }
-    return {
-      success: failed === 0,
-      total: workers.length,
-      succeeded,
-      failed,
-      results,
-      errors,
-      dryRun
-    };
-  }
-  async bulkDeleteWorkers(accountId, scriptNames, options = {}) {
-    const {
-      concurrency = 3,
-      dryRun = false,
-      onProgress,
-      continueOnError = false,
-      delayMs = 500
-    } = options;
-    const results = [];
-    const errors = [];
-    let completed = 0;
-    let succeeded = 0;
-    let failed = 0;
-    const reportProgress = () => {
-      onProgress?.({
-        total: scriptNames.length,
-        completed,
-        succeeded,
-        failed,
-        errors
-      });
-    };
-    for (let i = 0;i < scriptNames.length; i += concurrency) {
-      const batch = scriptNames.slice(i, i + concurrency);
-      const batchPromises = batch.map(async (name) => {
-        try {
-          if (dryRun) {
-            results.push({ name });
-            succeeded++;
-          } else {
-            await this.workers.delete(accountId, name);
-            results.push({ name });
-            succeeded++;
-          }
-        } catch (err) {
-          failed++;
-          errors.push({
-            item: `Worker: ${name}`,
-            error: err instanceof Error ? err.message : String(err)
-          });
-          if (!continueOnError) {
-            throw err;
-          }
-        } finally {
-          completed++;
-          reportProgress();
-        }
-      });
-      try {
-        await Promise.all(batchPromises);
-      } catch {
-        if (!continueOnError)
-          break;
-      }
-      if (delayMs > 0 && i + concurrency < scriptNames.length) {
-        await this.delay(delayMs);
-      }
-    }
-    return {
-      success: failed === 0,
-      total: scriptNames.length,
-      succeeded,
-      failed,
-      results,
-      errors,
-      dryRun
-    };
-  }
-  delay(ms) {
-    return new Promise((resolve) => setTimeout(resolve, ms));
-  }
-  exportDNSToJSON(records, includeIds = false) {
-    const exportRecords = records.map((r) => ({
-      ...includeIds ? { id: r.id } : {},
-      type: r.type,
-      name: r.name,
-      content: r.content,
-      ttl: r.ttl,
-      proxied: r.proxied,
-      priority: r.priority,
-      comment: r.comment
-    }));
-    return JSON.stringify(exportRecords, null, 2);
-  }
-  exportDNSToCSV(records, includeIds = false) {
-    const headers = includeIds ? ["id", "type", "name", "content", "ttl", "proxied", "priority", "comment"] : ["type", "name", "content", "ttl", "proxied", "priority", "comment"];
-    const rows = records.map((r) => {
-      const values = includeIds ? [r.id, r.type, r.name, r.content, r.ttl, r.proxied, r.priority ?? "", r.comment ?? ""] : [r.type, r.name, r.content, r.ttl, r.proxied, r.priority ?? "", r.comment ?? ""];
-      return values.map((v) => this.escapeCSV(String(v))).join(",");
-    });
-    return [headers.join(","), ...rows].join(`
-`);
-  }
-  escapeCSV(value) {
-    if (value.includes(",") || value.includes('"') || value.includes(`
-`)) {
-      return `"${value.replace(/"/g, '""')}"`;
-    }
-    return value;
-  }
-  parseDNSFromJSON(data) {
-    const parsed = JSON.parse(data);
-    const records = Array.isArray(parsed) ? parsed : [parsed];
-    return records.map((r) => ({
-      type: String(r.type).toUpperCase(),
-      name: String(r.name),
-      content: String(r.content),
-      ttl: r.ttl ? Number(r.ttl) : undefined,
-      priority: r.priority ? Number(r.priority) : undefined,
-      proxied: r.proxied === true || r.proxied === "true",
-      comment: r.comment ? String(r.comment) : undefined
-    }));
-  }
-  parseDNSFromCSV(data) {
-    const lines = data.trim().split(`
-`);
-    if (lines.length < 2) {
-      throw new Error("CSV must have a header row and at least one data row");
-    }
-    const headers = this.parseCSVLine(lines[0]).map((h) => h.toLowerCase().trim());
-    const records = [];
-    for (let i = 1;i < lines.length; i++) {
-      const values = this.parseCSVLine(lines[i]);
-      const record = {};
-      headers.forEach((header, idx) => {
-        record[header] = values[idx];
-      });
-      records.push({
-        type: String(record.type).toUpperCase(),
-        name: String(record.name),
-        content: String(record.content),
-        ttl: record.ttl ? Number(record.ttl) : undefined,
-        priority: record.priority ? Number(record.priority) : undefined,
-        proxied: record.proxied === "true" || record.proxied === true,
-        comment: record.comment ? String(record.comment) : undefined
-      });
-    }
-    return records;
-  }
-  parseCSVLine(line) {
-    const values = [];
-    let current = "";
-    let inQuotes = false;
-    for (let i = 0;i < line.length; i++) {
-      const char = line[i];
-      if (char === '"') {
-        if (inQuotes && line[i + 1] === '"') {
-          current += '"';
-          i++;
-        } else {
-          inQuotes = !inQuotes;
-        }
-      } else if (char === "," && !inQuotes) {
-        values.push(current);
-        current = "";
-      } else {
-        current += char;
-      }
-    }
-    values.push(current);
-    return values;
-  }
-}
-
-// src/utils/config.ts
-import { existsSync, readFileSync, writeFileSync, mkdirSync, readdirSync, rmSync, renameSync } from "fs";
-import { homedir } from "os";
-import { join } from "path";
-var DEFAULT_PROFILE = "default";
-var CURRENT_PROFILE_FILE = "current_profile";
-var PROFILES_DIR = "profiles";
-var profileOverride;
-function resolveBaseConfigDir() {
-  return join(homedir(), ".connectors", "connect-cloudflare");
-}
-var BASE_CONFIG_DIR = resolveBaseConfigDir();
-function ensureBaseConfigDir() {
-  if (!existsSync(BASE_CONFIG_DIR)) {
-    mkdirSync(BASE_CONFIG_DIR, { recursive: true });
-  }
-}
-function getProfilesDir() {
-  return join(BASE_CONFIG_DIR, PROFILES_DIR);
-}
-function getCurrentProfileFile() {
-  return join(BASE_CONFIG_DIR, CURRENT_PROFILE_FILE);
-}
-function migrateToProfileStructure() {
-  const profilesDir = getProfilesDir();
-  const defaultProfileDir = join(profilesDir, DEFAULT_PROFILE);
-  if (existsSync(profilesDir)) {
-    return;
-  }
-  const oldConfigFile = join(BASE_CONFIG_DIR, "config.json");
-  const hasOldStructure = existsSync(oldConfigFile);
-  if (!hasOldStructure) {
-    mkdirSync(profilesDir, { recursive: true });
-    return;
-  }
-  mkdirSync(defaultProfileDir, { recursive: true });
-  if (existsSync(oldConfigFile)) {
-    renameSync(oldConfigFile, join(defaultProfileDir, "config.json"));
-  }
-  writeFileSync(getCurrentProfileFile(), DEFAULT_PROFILE);
-}
-function getCurrentProfile() {
-  if (profileOverride) {
-    return profileOverride;
-  }
-  ensureBaseConfigDir();
-  migrateToProfileStructure();
-  const currentProfileFile = getCurrentProfileFile();
-  if (existsSync(currentProfileFile)) {
-    try {
-      const profile = readFileSync(currentProfileFile, "utf-8").trim();
-      if (profile && profileExists(profile)) {
-        return profile;
-      }
-    } catch {}
-  }
-  return DEFAULT_PROFILE;
-}
-function profileExists(profile) {
-  const profileDir = join(getProfilesDir(), profile);
-  return existsSync(profileDir);
-}
-function resolveConfigDir() {
-  ensureBaseConfigDir();
-  migrateToProfileStructure();
-  const profile = getCurrentProfile();
-  const profileDir = join(getProfilesDir(), profile);
-  if (!existsSync(profileDir)) {
-    mkdirSync(profileDir, { recursive: true });
-  }
-  return profileDir;
-}
-function getConfigDirInternal() {
-  return resolveConfigDir();
-}
-function ensureConfigDir() {
-  const configDir = getConfigDirInternal();
-  if (!existsSync(configDir)) {
-    mkdirSync(configDir, { recursive: true });
-  }
-}
-function loadConfig() {
-  ensureConfigDir();
-  const configFile = join(getConfigDirInternal(), "config.json");
-  if (!existsSync(configFile)) {
-    return {};
-  }
-  try {
-    const content = readFileSync(configFile, "utf-8");
-    return JSON.parse(content);
-  } catch {
-    return {};
-  }
-}
-function getApiToken() {
-  const config = loadConfig();
-  return process.env.CLOUDFLARE_API_TOKEN || config.apiToken || config.apiKey;
-}
-function getApiKey() {
-  return process.env.CLOUDFLARE_API_KEY || loadConfig().apiKey;
-}
-function getEmail() {
-  return process.env.CLOUDFLARE_EMAIL || loadConfig().email;
-}
-function getAccountId() {
-  return process.env.CLOUDFLARE_ACCOUNT_ID || loadConfig().accountId;
-}
-
-// src/api/index.ts
-class Cloudflare {
-  client;
-  zones;
-  dns;
-  workers;
-  pages;
-  kv;
-  r2;
-  cache;
-  analytics;
-  firewall;
-  ssl;
-  accounts;
-  bulk;
-  constructor(config) {
-    this.client = new CloudflareClient(config);
-    this.zones = new ZonesApi(this.client);
-    this.dns = new DNSApi(this.client);
-    this.workers = new WorkersApi(this.client);
-    this.pages = new PagesApi(this.client);
-    this.kv = new KVApi(this.client);
-    this.r2 = new R2Api(this.client);
-    this.cache = new CacheApi(this.client);
-    this.analytics = new AnalyticsApi(this.client);
-    this.firewall = new FirewallApi(this.client);
-    this.ssl = new SSLApi(this.client);
-    this.accounts = new AccountsApi(this.client);
-    this.bulk = new BulkApi(this.client);
-  }
-  static create() {
-    const apiToken = getApiToken();
-    const apiKey = getApiKey();
-    const email = getEmail();
-    const accountId = getAccountId();
-    if (!apiToken && !(apiKey && email)) {
-      throw new Error("Cloudflare credentials not configured. " + "Set CLOUDFLARE_API_TOKEN or (CLOUDFLARE_API_KEY + CLOUDFLARE_EMAIL), " + 'or run "connect-cloudflare config set-token <token>"');
-    }
-    return new Cloudflare({
-      apiToken,
-      apiKey,
-      email,
-      accountId
-    });
-  }
-  static fromEnv() {
-    const apiToken = process.env.CLOUDFLARE_API_TOKEN;
-    const apiKey = process.env.CLOUDFLARE_API_KEY;
-    const email = process.env.CLOUDFLARE_EMAIL;
-    const accountId = process.env.CLOUDFLARE_ACCOUNT_ID;
-    if (!apiToken && !(apiKey && email)) {
-      throw new Error("CLOUDFLARE_API_TOKEN or (CLOUDFLARE_API_KEY + CLOUDFLARE_EMAIL) environment variables are required");
-    }
-    return new Cloudflare({
-      apiToken,
-      apiKey,
-      email,
-      accountId
-    });
-  }
-  getCredentialPreview() {
-    return this.client.getCredentialPreview();
-  }
-  getAccountId() {
-    return this.client.getAccountId();
-  }
-  getClient() {
-    return this.client;
-  }
-}
-export {
-  ZonesApi,
-  WorkersApi,
-  SSLApi,
-  R2Api,
-  PagesApi,
-  KVApi,
-  FirewallApi,
-  DNSApi,
-  CloudflareClient,
-  CloudflareApiError,
-  Cloudflare,
-  CacheApi,
-  AnalyticsApi,
-  AccountsApi
-};