@tpmjs/tools-cloudflare 0.1.0

package/README.md

@@ -0,0 +1,58 @@
+# @tpmjs/tools-cloudflare
+
+Cloudflare API tools for AI agents. Manage DNS records, zones, Workers, KV namespaces, and purge cache.
+
+## Installation
+
+```bash
+npm install @tpmjs/tools-cloudflare
+```
+
+## Setup
+
+Set your Cloudflare API token and account ID:
+
+```bash
+export CLOUDFLARE_API_TOKEN="..."
+export CLOUDFLARE_ACCOUNT_ID="..."  # Required for Workers and KV operations
+```
+
+## Usage
+
+```typescript
+import { listZones, listDnsRecords, createDnsRecord } from '@tpmjs/tools-cloudflare';
+
+const zones = await listZones.execute({ per_page: 10 });
+const records = await listDnsRecords.execute({ zone_id: 'abc123', type: 'A' });
+const newRecord = await createDnsRecord.execute({
+  zone_id: 'abc123',
+  type: 'A',
+  name: 'app.example.com',
+  content: '1.2.3.4',
+  proxied: true,
+});
+```
+
+## Tools
+
+| Tool | Description |
+|------|-------------|
+| `listZones` | List zones with name and status filters |
+| `getZone` | Get details of a specific zone |
+| `purgeCache` | Purge cached content by URLs or purge everything |
+| `listDnsRecords` | List DNS records with type and name filters |
+| `createDnsRecord` | Create a new DNS record |
+| `updateDnsRecord` | Update an existing DNS record |
+| `deleteDnsRecord` | Delete a DNS record |
+| `listWorkers` | List all Workers scripts |
+| `getWorker` | Get metadata for a Worker script |
+| `deleteWorker` | Delete a Worker script |
+| `listKvNamespaces` | List KV namespaces |
+| `listKvKeys` | List keys in a KV namespace |
+| `getKvValue` | Get a value from KV |
+| `putKvValue` | Write a key-value pair to KV |
+| `deleteKvKey` | Delete a key from KV |
+
+## License
+
+MIT

package/dist/index.d.ts

@@ -0,0 +1,350 @@
+import * as ai from 'ai';
+
+interface ListZonesInput {
+    name?: string;
+    status?: string;
+    per_page?: number;
+}
+interface GetZoneInput {
+    zone_id: string;
+}
+interface PurgeCacheInput {
+    zone_id: string;
+    purge_everything?: boolean;
+    files?: string[];
+}
+interface ListDnsRecordsInput {
+    zone_id: string;
+    type?: string;
+    name?: string;
+    per_page?: number;
+}
+interface CreateDnsRecordInput {
+    zone_id: string;
+    type: string;
+    name: string;
+    content: string;
+    ttl?: number;
+    proxied?: boolean;
+}
+interface UpdateDnsRecordInput {
+    zone_id: string;
+    record_id: string;
+    type: string;
+    name: string;
+    content: string;
+    ttl?: number;
+    proxied?: boolean;
+}
+interface DeleteDnsRecordInput {
+    zone_id: string;
+    record_id: string;
+}
+interface ListWorkersInput {
+    per_page?: number;
+}
+interface GetWorkerInput {
+    script_name: string;
+}
+interface DeleteWorkerInput {
+    script_name: string;
+}
+interface ListKvNamespacesInput {
+    per_page?: number;
+}
+interface ListKvKeysInput {
+    namespace_id: string;
+    prefix?: string;
+    limit?: number;
+}
+interface GetKvValueInput {
+    namespace_id: string;
+    key_name: string;
+}
+interface PutKvValueInput {
+    namespace_id: string;
+    key_name: string;
+    value: string;
+}
+interface DeleteKvKeyInput {
+    namespace_id: string;
+    key_name: string;
+}
+declare const listZones: ai.Tool<ListZonesInput, {
+    success: boolean;
+    data: unknown;
+    error?: undefined;
+} | {
+    success: boolean;
+    error: string;
+    data?: undefined;
+}>;
+declare const getZone: ai.Tool<GetZoneInput, {
+    success: boolean;
+    data: unknown;
+    error?: undefined;
+} | {
+    success: boolean;
+    error: string;
+    data?: undefined;
+}>;
+declare const purgeCache: ai.Tool<PurgeCacheInput, {
+    success: boolean;
+    data: unknown;
+    error?: undefined;
+} | {
+    success: boolean;
+    error: string;
+    data?: undefined;
+}>;
+declare const listDnsRecords: ai.Tool<ListDnsRecordsInput, {
+    success: boolean;
+    data: unknown;
+    error?: undefined;
+} | {
+    success: boolean;
+    error: string;
+    data?: undefined;
+}>;
+declare const createDnsRecord: ai.Tool<CreateDnsRecordInput, {
+    success: boolean;
+    data: unknown;
+    error?: undefined;
+} | {
+    success: boolean;
+    error: string;
+    data?: undefined;
+}>;
+declare const updateDnsRecord: ai.Tool<UpdateDnsRecordInput, {
+    success: boolean;
+    data: unknown;
+    error?: undefined;
+} | {
+    success: boolean;
+    error: string;
+    data?: undefined;
+}>;
+declare const deleteDnsRecord: ai.Tool<DeleteDnsRecordInput, {
+    success: boolean;
+    data: unknown;
+    error?: undefined;
+} | {
+    success: boolean;
+    error: string;
+    data?: undefined;
+}>;
+declare const listWorkers: ai.Tool<ListWorkersInput, {
+    success: boolean;
+    data: unknown;
+    error?: undefined;
+} | {
+    success: boolean;
+    error: string;
+    data?: undefined;
+}>;
+declare const getWorker: ai.Tool<GetWorkerInput, {
+    success: boolean;
+    data: unknown;
+    error?: undefined;
+} | {
+    success: boolean;
+    error: string;
+    data?: undefined;
+}>;
+declare const deleteWorker: ai.Tool<DeleteWorkerInput, {
+    success: boolean;
+    data: unknown;
+    error?: undefined;
+} | {
+    success: boolean;
+    error: string;
+    data?: undefined;
+}>;
+declare const listKvNamespaces: ai.Tool<ListKvNamespacesInput, {
+    success: boolean;
+    data: unknown;
+    error?: undefined;
+} | {
+    success: boolean;
+    error: string;
+    data?: undefined;
+}>;
+declare const listKvKeys: ai.Tool<ListKvKeysInput, {
+    success: boolean;
+    data: unknown;
+    error?: undefined;
+} | {
+    success: boolean;
+    error: string;
+    data?: undefined;
+}>;
+declare const getKvValue: ai.Tool<GetKvValueInput, {
+    success: boolean;
+    data: {
+        value: string;
+    };
+    error?: undefined;
+} | {
+    success: boolean;
+    error: string;
+    data?: undefined;
+}>;
+declare const putKvValue: ai.Tool<PutKvValueInput, {
+    success: boolean;
+    data: unknown;
+    error?: undefined;
+} | {
+    success: boolean;
+    error: string;
+    data?: undefined;
+}>;
+declare const deleteKvKey: ai.Tool<DeleteKvKeyInput, {
+    success: boolean;
+    data: unknown;
+    error?: undefined;
+} | {
+    success: boolean;
+    error: string;
+    data?: undefined;
+}>;
+declare const _default: {
+    listZones: ai.Tool<ListZonesInput, {
+        success: boolean;
+        data: unknown;
+        error?: undefined;
+    } | {
+        success: boolean;
+        error: string;
+        data?: undefined;
+    }>;
+    getZone: ai.Tool<GetZoneInput, {
+        success: boolean;
+        data: unknown;
+        error?: undefined;
+    } | {
+        success: boolean;
+        error: string;
+        data?: undefined;
+    }>;
+    purgeCache: ai.Tool<PurgeCacheInput, {
+        success: boolean;
+        data: unknown;
+        error?: undefined;
+    } | {
+        success: boolean;
+        error: string;
+        data?: undefined;
+    }>;
+    listDnsRecords: ai.Tool<ListDnsRecordsInput, {
+        success: boolean;
+        data: unknown;
+        error?: undefined;
+    } | {
+        success: boolean;
+        error: string;
+        data?: undefined;
+    }>;
+    createDnsRecord: ai.Tool<CreateDnsRecordInput, {
+        success: boolean;
+        data: unknown;
+        error?: undefined;
+    } | {
+        success: boolean;
+        error: string;
+        data?: undefined;
+    }>;
+    updateDnsRecord: ai.Tool<UpdateDnsRecordInput, {
+        success: boolean;
+        data: unknown;
+        error?: undefined;
+    } | {
+        success: boolean;
+        error: string;
+        data?: undefined;
+    }>;
+    deleteDnsRecord: ai.Tool<DeleteDnsRecordInput, {
+        success: boolean;
+        data: unknown;
+        error?: undefined;
+    } | {
+        success: boolean;
+        error: string;
+        data?: undefined;
+    }>;
+    listWorkers: ai.Tool<ListWorkersInput, {
+        success: boolean;
+        data: unknown;
+        error?: undefined;
+    } | {
+        success: boolean;
+        error: string;
+        data?: undefined;
+    }>;
+    getWorker: ai.Tool<GetWorkerInput, {
+        success: boolean;
+        data: unknown;
+        error?: undefined;
+    } | {
+        success: boolean;
+        error: string;
+        data?: undefined;
+    }>;
+    deleteWorker: ai.Tool<DeleteWorkerInput, {
+        success: boolean;
+        data: unknown;
+        error?: undefined;
+    } | {
+        success: boolean;
+        error: string;
+        data?: undefined;
+    }>;
+    listKvNamespaces: ai.Tool<ListKvNamespacesInput, {
+        success: boolean;
+        data: unknown;
+        error?: undefined;
+    } | {
+        success: boolean;
+        error: string;
+        data?: undefined;
+    }>;
+    listKvKeys: ai.Tool<ListKvKeysInput, {
+        success: boolean;
+        data: unknown;
+        error?: undefined;
+    } | {
+        success: boolean;
+        error: string;
+        data?: undefined;
+    }>;
+    getKvValue: ai.Tool<GetKvValueInput, {
+        success: boolean;
+        data: {
+            value: string;
+        };
+        error?: undefined;
+    } | {
+        success: boolean;
+        error: string;
+        data?: undefined;
+    }>;
+    putKvValue: ai.Tool<PutKvValueInput, {
+        success: boolean;
+        data: unknown;
+        error?: undefined;
+    } | {
+        success: boolean;
+        error: string;
+        data?: undefined;
+    }>;
+    deleteKvKey: ai.Tool<DeleteKvKeyInput, {
+        success: boolean;
+        data: unknown;
+        error?: undefined;
+    } | {
+        success: boolean;
+        error: string;
+        data?: undefined;
+    }>;
+};
+
+export { createDnsRecord, _default as default, deleteDnsRecord, deleteKvKey, deleteWorker, getKvValue, getWorker, getZone, listDnsRecords, listKvKeys, listKvNamespaces, listWorkers, listZones, purgeCache, putKvValue, updateDnsRecord };

package/dist/index.js

@@ -0,0 +1,772 @@
+import { tool, jsonSchema } from 'ai';
+
+// src/index.ts
+var BASE_URL = "https://api.cloudflare.com/client/v4";
+function getApiToken() {
+  const token = process.env.CLOUDFLARE_API_TOKEN;
+  if (!token) {
+    throw new Error(
+      "CLOUDFLARE_API_TOKEN environment variable is required. Get your token at https://dash.cloudflare.com/profile/api-tokens"
+    );
+  }
+  return token;
+}
+function getAccountId() {
+  const accountId = process.env.CLOUDFLARE_ACCOUNT_ID;
+  if (!accountId) {
+    throw new Error(
+      "CLOUDFLARE_ACCOUNT_ID environment variable is required. Find it at https://dash.cloudflare.com/"
+    );
+  }
+  return accountId;
+}
+function buildQueryString(params) {
+  const searchParams = new URLSearchParams();
+  for (const [key, value] of Object.entries(params)) {
+    if (value !== void 0 && value !== null) {
+      searchParams.append(key, String(value));
+    }
+  }
+  const query = searchParams.toString();
+  return query ? `?${query}` : "";
+}
+async function apiRequest(endpoint, options = {}) {
+  const token = getApiToken();
+  const url = `${BASE_URL}${endpoint}`;
+  const response = await fetch(url, {
+    ...options,
+    headers: {
+      Authorization: `Bearer ${token}`,
+      "Content-Type": "application/json",
+      ...options.headers
+    }
+  });
+  const data = await response.json();
+  if (!data.success) {
+    const errorMessages = data.errors.map((err) => `[${err.code}] ${err.message}`).join("; ");
+    throw new Error(`Cloudflare API error: ${errorMessages}`);
+  }
+  return data.result;
+}
+async function apiRequestRaw(endpoint, options = {}) {
+  const token = getApiToken();
+  const url = `${BASE_URL}${endpoint}`;
+  const response = await fetch(url, {
+    ...options,
+    headers: {
+      Authorization: `Bearer ${token}`,
+      ...options.headers
+    }
+  });
+  if (!response.ok) {
+    const errorText = await response.text();
+    throw new Error(
+      `Cloudflare API error: ${response.status} ${response.statusText} - ${errorText}`
+    );
+  }
+  return response.text();
+}
+function handleApiError(error) {
+  if (error instanceof Error) {
+    return error.message;
+  }
+  return "An unknown error occurred";
+}
+var listZones = tool({
+  description: "List all zones (domains) in your Cloudflare account with optional filtering",
+  inputSchema: jsonSchema({
+    type: "object",
+    properties: {
+      name: {
+        type: "string",
+        description: "Filter zones by name (domain)"
+      },
+      status: {
+        type: "string",
+        description: 'Filter by zone status (e.g., "active", "pending")'
+      },
+      per_page: {
+        type: "number",
+        description: "Number of results per page (default: 20, max: 50)"
+      }
+    },
+    additionalProperties: false
+  }),
+  execute: async ({ name, status, per_page }) => {
+    try {
+      const queryParams = {};
+      if (name) queryParams.name = name;
+      if (status) queryParams.status = status;
+      if (per_page) queryParams.per_page = per_page;
+      const query = buildQueryString(queryParams);
+      const result = await apiRequest(`/zones${query}`);
+      return {
+        success: true,
+        data: result
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: handleApiError(error)
+      };
+    }
+  }
+});
+var getZone = tool({
+  description: "Get detailed information about a specific zone",
+  inputSchema: jsonSchema({
+    type: "object",
+    properties: {
+      zone_id: {
+        type: "string",
+        description: "The zone ID to retrieve"
+      }
+    },
+    required: ["zone_id"],
+    additionalProperties: false
+  }),
+  execute: async ({ zone_id }) => {
+    try {
+      if (!zone_id) {
+        throw new Error("zone_id is required");
+      }
+      const result = await apiRequest(`/zones/${zone_id}`);
+      return {
+        success: true,
+        data: result
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: handleApiError(error)
+      };
+    }
+  }
+});
+var purgeCache = tool({
+  description: "Purge cached content from Cloudflare CDN for a zone (all files or specific URLs)",
+  inputSchema: jsonSchema({
+    type: "object",
+    properties: {
+      zone_id: {
+        type: "string",
+        description: "The zone ID to purge cache for"
+      },
+      purge_everything: {
+        type: "boolean",
+        description: "Purge all cached content (default: false)"
+      },
+      files: {
+        type: "array",
+        items: { type: "string" },
+        description: "Array of URLs to purge (use if purge_everything is false)"
+      }
+    },
+    required: ["zone_id"],
+    additionalProperties: false
+  }),
+  execute: async ({ zone_id, purge_everything, files }) => {
+    try {
+      if (!zone_id) {
+        throw new Error("zone_id is required");
+      }
+      const body = {};
+      if (purge_everything) {
+        body.purge_everything = true;
+      } else if (files && files.length > 0) {
+        body.files = files;
+      } else {
+        throw new Error(
+          "Either purge_everything must be true or files must be provided"
+        );
+      }
+      const result = await apiRequest(
+        `/zones/${zone_id}/purge_cache`,
+        {
+          method: "POST",
+          body: JSON.stringify(body)
+        }
+      );
+      return {
+        success: true,
+        data: result
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: handleApiError(error)
+      };
+    }
+  }
+});
+var listDnsRecords = tool({
+  description: "List DNS records for a specific zone with optional filtering",
+  inputSchema: jsonSchema({
+    type: "object",
+    properties: {
+      zone_id: {
+        type: "string",
+        description: "The zone ID to list DNS records for"
+      },
+      type: {
+        type: "string",
+        description: "Filter by record type (A, AAAA, CNAME, MX, TXT, etc.)"
+      },
+      name: {
+        type: "string",
+        description: 'Filter by record name (e.g., "example.com")'
+      },
+      per_page: {
+        type: "number",
+        description: "Number of results per page (default: 20, max: 100)"
+      }
+    },
+    required: ["zone_id"],
+    additionalProperties: false
+  }),
+  execute: async ({ zone_id, type, name, per_page }) => {
+    try {
+      if (!zone_id) {
+        throw new Error("zone_id is required");
+      }
+      const queryParams = {};
+      if (type) queryParams.type = type;
+      if (name) queryParams.name = name;
+      if (per_page) queryParams.per_page = per_page;
+      const query = buildQueryString(queryParams);
+      const result = await apiRequest(
+        `/zones/${zone_id}/dns_records${query}`
+      );
+      return {
+        success: true,
+        data: result
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: handleApiError(error)
+      };
+    }
+  }
+});
+var createDnsRecord = tool({
+  description: "Create a new DNS record in a zone",
+  inputSchema: jsonSchema({
+    type: "object",
+    properties: {
+      zone_id: {
+        type: "string",
+        description: "The zone ID to create the DNS record in"
+      },
+      type: {
+        type: "string",
+        description: "DNS record type (A, AAAA, CNAME, MX, TXT, etc.)"
+      },
+      name: {
+        type: "string",
+        description: 'DNS record name (e.g., "example.com" or "subdomain.example.com")'
+      },
+      content: {
+        type: "string",
+        description: "DNS record content (e.g., IP address for A record, domain for CNAME)"
+      },
+      ttl: {
+        type: "number",
+        description: "Time to live in seconds (1 = automatic, default: 1)"
+      },
+      proxied: {
+        type: "boolean",
+        description: "Whether the record is proxied through Cloudflare (default: false)"
+      }
+    },
+    required: ["zone_id", "type", "name", "content"],
+    additionalProperties: false
+  }),
+  execute: async ({ zone_id, type, name, content, ttl, proxied }) => {
+    try {
+      if (!zone_id || !type || !name || !content) {
+        throw new Error("zone_id, type, name, and content are required");
+      }
+      const body = {
+        type,
+        name,
+        content
+      };
+      if (ttl !== void 0) body.ttl = ttl;
+      if (proxied !== void 0) body.proxied = proxied;
+      const result = await apiRequest(
+        `/zones/${zone_id}/dns_records`,
+        {
+          method: "POST",
+          body: JSON.stringify(body)
+        }
+      );
+      return {
+        success: true,
+        data: result
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: handleApiError(error)
+      };
+    }
+  }
+});
+var updateDnsRecord = tool({
+  description: "Update an existing DNS record",
+  inputSchema: jsonSchema({
+    type: "object",
+    properties: {
+      zone_id: {
+        type: "string",
+        description: "The zone ID containing the DNS record"
+      },
+      record_id: {
+        type: "string",
+        description: "The DNS record ID to update"
+      },
+      type: {
+        type: "string",
+        description: "DNS record type (A, AAAA, CNAME, MX, TXT, etc.)"
+      },
+      name: {
+        type: "string",
+        description: 'DNS record name (e.g., "example.com" or "subdomain.example.com")'
+      },
+      content: {
+        type: "string",
+        description: "DNS record content (e.g., IP address for A record, domain for CNAME)"
+      },
+      ttl: {
+        type: "number",
+        description: "Time to live in seconds (1 = automatic)"
+      },
+      proxied: {
+        type: "boolean",
+        description: "Whether the record is proxied through Cloudflare"
+      }
+    },
+    required: ["zone_id", "record_id", "type", "name", "content"],
+    additionalProperties: false
+  }),
+  execute: async ({
+    zone_id,
+    record_id,
+    type,
+    name,
+    content,
+    ttl,
+    proxied
+  }) => {
+    try {
+      if (!zone_id || !record_id || !type || !name || !content) {
+        throw new Error(
+          "zone_id, record_id, type, name, and content are required"
+        );
+      }
+      const body = {
+        type,
+        name,
+        content
+      };
+      if (ttl !== void 0) body.ttl = ttl;
+      if (proxied !== void 0) body.proxied = proxied;
+      const result = await apiRequest(
+        `/zones/${zone_id}/dns_records/${record_id}`,
+        {
+          method: "PUT",
+          body: JSON.stringify(body)
+        }
+      );
+      return {
+        success: true,
+        data: result
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: handleApiError(error)
+      };
+    }
+  }
+});
+var deleteDnsRecord = tool({
+  description: "Delete a DNS record from a zone",
+  inputSchema: jsonSchema({
+    type: "object",
+    properties: {
+      zone_id: {
+        type: "string",
+        description: "The zone ID containing the DNS record"
+      },
+      record_id: {
+        type: "string",
+        description: "The DNS record ID to delete"
+      }
+    },
+    required: ["zone_id", "record_id"],
+    additionalProperties: false
+  }),
+  execute: async ({ zone_id, record_id }) => {
+    try {
+      if (!zone_id || !record_id) {
+        throw new Error("zone_id and record_id are required");
+      }
+      const result = await apiRequest(
+        `/zones/${zone_id}/dns_records/${record_id}`,
+        {
+          method: "DELETE"
+        }
+      );
+      return {
+        success: true,
+        data: result
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: handleApiError(error)
+      };
+    }
+  }
+});
+var listWorkers = tool({
+  description: "List all Cloudflare Workers scripts in your account",
+  inputSchema: jsonSchema({
+    type: "object",
+    properties: {
+      per_page: {
+        type: "number",
+        description: "Number of results per page (default: 20)"
+      }
+    },
+    additionalProperties: false
+  }),
+  execute: async ({ per_page }) => {
+    try {
+      const accountId = getAccountId();
+      const queryParams = {};
+      if (per_page) queryParams.per_page = per_page;
+      const query = buildQueryString(queryParams);
+      const result = await apiRequest(
+        `/accounts/${accountId}/workers/scripts${query}`
+      );
+      return {
+        success: true,
+        data: result
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: handleApiError(error)
+      };
+    }
+  }
+});
+var getWorker = tool({
+  description: "Get settings and metadata for a specific Cloudflare Worker",
+  inputSchema: jsonSchema({
+    type: "object",
+    properties: {
+      script_name: {
+        type: "string",
+        description: "The name of the Worker script"
+      }
+    },
+    required: ["script_name"],
+    additionalProperties: false
+  }),
+  execute: async ({ script_name }) => {
+    try {
+      if (!script_name) {
+        throw new Error("script_name is required");
+      }
+      const accountId = getAccountId();
+      const result = await apiRequest(
+        `/accounts/${accountId}/workers/scripts/${script_name}/settings`
+      );
+      return {
+        success: true,
+        data: result
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: handleApiError(error)
+      };
+    }
+  }
+});
+var deleteWorker = tool({
+  description: "Delete a Cloudflare Worker script",
+  inputSchema: jsonSchema({
+    type: "object",
+    properties: {
+      script_name: {
+        type: "string",
+        description: "The name of the Worker script to delete"
+      }
+    },
+    required: ["script_name"],
+    additionalProperties: false
+  }),
+  execute: async ({ script_name }) => {
+    try {
+      if (!script_name) {
+        throw new Error("script_name is required");
+      }
+      const accountId = getAccountId();
+      const result = await apiRequest(
+        `/accounts/${accountId}/workers/scripts/${script_name}`,
+        {
+          method: "DELETE"
+        }
+      );
+      return {
+        success: true,
+        data: result
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: handleApiError(error)
+      };
+    }
+  }
+});
+var listKvNamespaces = tool({
+  description: "List all KV namespaces in your Cloudflare account",
+  inputSchema: jsonSchema({
+    type: "object",
+    properties: {
+      per_page: {
+        type: "number",
+        description: "Number of results per page (default: 20)"
+      }
+    },
+    additionalProperties: false
+  }),
+  execute: async ({ per_page }) => {
+    try {
+      const accountId = getAccountId();
+      const queryParams = {};
+      if (per_page) queryParams.per_page = per_page;
+      const query = buildQueryString(queryParams);
+      const result = await apiRequest(
+        `/accounts/${accountId}/storage/kv/namespaces${query}`
+      );
+      return {
+        success: true,
+        data: result
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: handleApiError(error)
+      };
+    }
+  }
+});
+var listKvKeys = tool({
+  description: "List all keys in a KV namespace with optional filtering",
+  inputSchema: jsonSchema({
+    type: "object",
+    properties: {
+      namespace_id: {
+        type: "string",
+        description: "The KV namespace ID"
+      },
+      prefix: {
+        type: "string",
+        description: "Filter keys by prefix"
+      },
+      limit: {
+        type: "number",
+        description: "Maximum number of keys to return (default: 1000)"
+      }
+    },
+    required: ["namespace_id"],
+    additionalProperties: false
+  }),
+  execute: async ({ namespace_id, prefix, limit }) => {
+    try {
+      if (!namespace_id) {
+        throw new Error("namespace_id is required");
+      }
+      const accountId = getAccountId();
+      const queryParams = {};
+      if (prefix) queryParams.prefix = prefix;
+      if (limit) queryParams.limit = limit;
+      const query = buildQueryString(queryParams);
+      const result = await apiRequest(
+        `/accounts/${accountId}/storage/kv/namespaces/${namespace_id}/keys${query}`
+      );
+      return {
+        success: true,
+        data: result
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: handleApiError(error)
+      };
+    }
+  }
+});
+var getKvValue = tool({
+  description: "Get the value of a key from a KV namespace",
+  inputSchema: jsonSchema({
+    type: "object",
+    properties: {
+      namespace_id: {
+        type: "string",
+        description: "The KV namespace ID"
+      },
+      key_name: {
+        type: "string",
+        description: "The key name to retrieve"
+      }
+    },
+    required: ["namespace_id", "key_name"],
+    additionalProperties: false
+  }),
+  execute: async ({ namespace_id, key_name }) => {
+    try {
+      if (!namespace_id || !key_name) {
+        throw new Error("namespace_id and key_name are required");
+      }
+      const accountId = getAccountId();
+      const value = await apiRequestRaw(
+        `/accounts/${accountId}/storage/kv/namespaces/${namespace_id}/values/${key_name}`
+      );
+      return {
+        success: true,
+        data: { value }
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: handleApiError(error)
+      };
+    }
+  }
+});
+var putKvValue = tool({
+  description: "Set the value of a key in a KV namespace",
+  inputSchema: jsonSchema({
+    type: "object",
+    properties: {
+      namespace_id: {
+        type: "string",
+        description: "The KV namespace ID"
+      },
+      key_name: {
+        type: "string",
+        description: "The key name to set"
+      },
+      value: {
+        type: "string",
+        description: "The value to store (will be stored as text)"
+      }
+    },
+    required: ["namespace_id", "key_name", "value"],
+    additionalProperties: false
+  }),
+  execute: async ({ namespace_id, key_name, value }) => {
+    try {
+      if (!namespace_id || !key_name || value === void 0) {
+        throw new Error("namespace_id, key_name, and value are required");
+      }
+      const accountId = getAccountId();
+      const token = getApiToken();
+      const url = `${BASE_URL}/accounts/${accountId}/storage/kv/namespaces/${namespace_id}/values/${key_name}`;
+      const response = await fetch(url, {
+        method: "PUT",
+        headers: {
+          Authorization: `Bearer ${token}`,
+          "Content-Type": "text/plain"
+        },
+        body: value
+      });
+      const data = await response.json();
+      if (!data.success) {
+        const errorMessages = data.errors.map((err) => `[${err.code}] ${err.message}`).join("; ");
+        throw new Error(`Cloudflare API error: ${errorMessages}`);
+      }
+      return {
+        success: true,
+        data: data.result
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: handleApiError(error)
+      };
+    }
+  }
+});
+var deleteKvKey = tool({
+  description: "Delete a key from a KV namespace",
+  inputSchema: jsonSchema({
+    type: "object",
+    properties: {
+      namespace_id: {
+        type: "string",
+        description: "The KV namespace ID"
+      },
+      key_name: {
+        type: "string",
+        description: "The key name to delete"
+      }
+    },
+    required: ["namespace_id", "key_name"],
+    additionalProperties: false
+  }),
+  execute: async ({ namespace_id, key_name }) => {
+    try {
+      if (!namespace_id || !key_name) {
+        throw new Error("namespace_id and key_name are required");
+      }
+      const accountId = getAccountId();
+      const result = await apiRequest(
+        `/accounts/${accountId}/storage/kv/namespaces/${namespace_id}/values/${key_name}`,
+        {
+          method: "DELETE"
+        }
+      );
+      return {
+        success: true,
+        data: result
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: handleApiError(error)
+      };
+    }
+  }
+});
+var index_default = {
+  // Zones
+  listZones,
+  getZone,
+  purgeCache,
+  // DNS Records
+  listDnsRecords,
+  createDnsRecord,
+  updateDnsRecord,
+  deleteDnsRecord,
+  // Workers
+  listWorkers,
+  getWorker,
+  deleteWorker,
+  // KV
+  listKvNamespaces,
+  listKvKeys,
+  getKvValue,
+  putKvValue,
+  deleteKvKey
+};
+
+export { createDnsRecord, index_default as default, deleteDnsRecord, deleteKvKey, deleteWorker, getKvValue, getWorker, getZone, listDnsRecords, listKvKeys, listKvNamespaces, listWorkers, listZones, purgeCache, putKvValue, updateDnsRecord };

package/package.json

@@ -0,0 +1,114 @@
+{
+  "name": "@tpmjs/tools-cloudflare",
+  "version": "0.1.0",
+  "description": "Cloudflare API tools for AI agents. Manage DNS records, zones, Workers, KV namespaces, and purge cache.",
+  "type": "module",
+  "keywords": [
+    "tpmjs",
+    "cloudflare",
+    "dns",
+    "workers",
+    "agent"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "type-check": "tsc --noEmit",
+    "clean": "rm -rf dist .turbo"
+  },
+  "devDependencies": {
+    "@tpmjs/tsconfig": "workspace:*",
+    "tsup": "^8.5.1",
+    "typescript": "^5.9.3"
+  },
+  "dependencies": {
+    "ai": "6.0.49"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/tpmjs/tpmjs.git",
+    "directory": "packages/tools/official/cloudflare"
+  },
+  "homepage": "https://tpmjs.com",
+  "license": "MIT",
+  "tpmjs": {
+    "category": "ops",
+    "frameworks": [
+      "vercel-ai"
+    ],
+    "tools": [
+      {
+        "name": "listZones",
+        "description": "List Cloudflare zones with optional name and status filtering."
+      },
+      {
+        "name": "getZone",
+        "description": "Get details of a specific Cloudflare zone by ID."
+      },
+      {
+        "name": "purgeCache",
+        "description": "Purge cached content from a Cloudflare zone by URLs or purge everything."
+      },
+      {
+        "name": "listDnsRecords",
+        "description": "List DNS records for a Cloudflare zone with type and name filters."
+      },
+      {
+        "name": "createDnsRecord",
+        "description": "Create a new DNS record in a Cloudflare zone."
+      },
+      {
+        "name": "updateDnsRecord",
+        "description": "Update an existing DNS record in a Cloudflare zone."
+      },
+      {
+        "name": "deleteDnsRecord",
+        "description": "Delete a DNS record from a Cloudflare zone."
+      },
+      {
+        "name": "listWorkers",
+        "description": "List all Workers scripts in your Cloudflare account."
+      },
+      {
+        "name": "getWorker",
+        "description": "Get metadata and bindings for a specific Worker script."
+      },
+      {
+        "name": "deleteWorker",
+        "description": "Delete a Worker script from your Cloudflare account."
+      },
+      {
+        "name": "listKvNamespaces",
+        "description": "List KV namespaces in your Cloudflare account."
+      },
+      {
+        "name": "listKvKeys",
+        "description": "List keys in a Cloudflare KV namespace with optional prefix filter."
+      },
+      {
+        "name": "getKvValue",
+        "description": "Get the value of a key from a Cloudflare KV namespace."
+      },
+      {
+        "name": "putKvValue",
+        "description": "Write a key-value pair to a Cloudflare KV namespace."
+      },
+      {
+        "name": "deleteKvKey",
+        "description": "Delete a key from a Cloudflare KV namespace."
+      }
+    ]
+  }
+}