@universal-mcp-toolkit/server-cloudflare-workers 0.1.0

package/.well-known/mcp-server.json

@@ -0,0 +1,36 @@
+{
+  "$schema": "https://json.schemastore.org/json",
+  "name": "cloudflare-workers",
+  "title": "Cloudflare Workers MCP Server",
+  "description": "Worker, route, and account tools for Cloudflare Workers.",
+  "version": "0.1.0",
+  "packageName": "@universal-mcp-toolkit/server-cloudflare-workers",
+  "homepage": "https://github.com/universal-mcp-toolkit/universal-mcp-toolkit",
+  "transports": [
+    "stdio",
+    "sse"
+  ],
+  "authentication": {
+    "mode": "environment-variables",
+    "required": [
+      "CLOUDFLARE_API_TOKEN",
+      "CLOUDFLARE_ACCOUNT_ID"
+    ]
+  },
+  "capabilities": {
+    "tools": true,
+    "resources": true,
+    "prompts": true
+  },
+  "tools": [
+    "list_workers",
+    "get_worker",
+    "list_routes"
+  ],
+  "resources": [
+    "account"
+  ],
+  "prompts": [
+    "edge-rollout"
+  ]
+}

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 universal-mcp-toolkit
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/index.d.ts

@@ -0,0 +1,62 @@
+import * as _universal_mcp_toolkit_core from '@universal-mcp-toolkit/core';
+import { ToolkitServer, ToolkitServerMetadata } from '@universal-mcp-toolkit/core';
+import { z } from 'zod';
+
+declare const metadata: ToolkitServerMetadata;
+declare const serverCard: _universal_mcp_toolkit_core.ToolkitServerCard;
+declare const workerSummarySchema: z.ZodObject<{
+    name: z.ZodString;
+    createdAt: z.ZodNullable<z.ZodString>;
+    modifiedAt: z.ZodNullable<z.ZodString>;
+    usageModel: z.ZodNullable<z.ZodString>;
+    handlers: z.ZodArray<z.ZodString>;
+    compatibilityDate: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+declare const workerDetailSchema: z.ZodObject<{
+    name: z.ZodString;
+    createdAt: z.ZodNullable<z.ZodString>;
+    modifiedAt: z.ZodNullable<z.ZodString>;
+    usageModel: z.ZodNullable<z.ZodString>;
+    handlers: z.ZodArray<z.ZodString>;
+    compatibilityDate: z.ZodNullable<z.ZodString>;
+    bindingsCount: z.ZodNumber;
+    placementMode: z.ZodNullable<z.ZodString>;
+    logpush: z.ZodBoolean;
+}, z.core.$strip>;
+declare const routeSchema: z.ZodObject<{
+    id: z.ZodString;
+    pattern: z.ZodString;
+    script: z.ZodNullable<z.ZodString>;
+    zoneName: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+declare const accountSummarySchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    type: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+type CloudflareWorkerSummary = z.infer<typeof workerSummarySchema>;
+type CloudflareWorkerDetail = z.infer<typeof workerDetailSchema>;
+type CloudflareRoute = z.infer<typeof routeSchema>;
+type CloudflareAccountSummary = z.infer<typeof accountSummarySchema>;
+interface CloudflareWorkersClient {
+    listWorkers(limit: number): Promise<ReadonlyArray<CloudflareWorkerSummary>>;
+    getWorker(scriptName: string): Promise<CloudflareWorkerDetail>;
+    listRoutes(input: {
+        limit: number;
+        scriptName?: string;
+    }): Promise<ReadonlyArray<CloudflareRoute>>;
+    getAccountSummary(): Promise<CloudflareAccountSummary>;
+}
+interface CreateCloudflareWorkersServerOptions {
+    client?: CloudflareWorkersClient;
+    env?: NodeJS.ProcessEnv;
+    fetch?: typeof fetch;
+}
+declare class CloudflareWorkersServer extends ToolkitServer {
+    private readonly client;
+    constructor(client: CloudflareWorkersClient);
+}
+declare function createServer(options?: CreateCloudflareWorkersServerOptions): Promise<CloudflareWorkersServer>;
+declare function main(argv?: readonly string[]): Promise<void>;
+
+export { type CloudflareAccountSummary, type CloudflareRoute, type CloudflareWorkerDetail, type CloudflareWorkerSummary, type CloudflareWorkersClient, CloudflareWorkersServer, type CreateCloudflareWorkersServerOptions, createServer, main, metadata, serverCard };

package/dist/index.js

@@ -0,0 +1,354 @@
+// src/index.ts
+import {
+  createServerCard,
+  defineTool,
+  ExternalServiceError,
+  loadEnv,
+  parseRuntimeOptions,
+  runToolkitServer,
+  ToolkitServer
+} from "@universal-mcp-toolkit/core";
+import { resolve } from "path";
+import { fileURLToPath } from "url";
+import { z } from "zod";
+var toolNames = ["list_workers", "get_worker", "list_routes"];
+var resourceNames = ["account"];
+var promptNames = ["edge-rollout"];
+var metadata = {
+  id: "cloudflare-workers",
+  title: "Cloudflare Workers MCP Server",
+  description: "Worker, route, and account tools for Cloudflare Workers.",
+  version: "0.1.0",
+  packageName: "@universal-mcp-toolkit/server-cloudflare-workers",
+  homepage: "https://github.com/universal-mcp-toolkit/universal-mcp-toolkit",
+  repositoryUrl: "https://github.com/universal-mcp-toolkit/universal-mcp-toolkit",
+  documentationUrl: "https://github.com/universal-mcp-toolkit/universal-mcp-toolkit/tree/main/servers/cloudflare-workers",
+  envVarNames: ["CLOUDFLARE_API_TOKEN", "CLOUDFLARE_ACCOUNT_ID"],
+  transports: ["stdio", "sse"],
+  toolNames,
+  resourceNames,
+  promptNames
+};
+var serverCard = createServerCard(metadata);
+var envShape = {
+  CLOUDFLARE_API_TOKEN: z.string().min(1),
+  CLOUDFLARE_ACCOUNT_ID: z.string().min(1),
+  CLOUDFLARE_API_BASE_URL: z.string().url().optional()
+};
+var workerSummarySchema = z.object({
+  name: z.string(),
+  createdAt: z.string().nullable(),
+  modifiedAt: z.string().nullable(),
+  usageModel: z.string().nullable(),
+  handlers: z.array(z.string()),
+  compatibilityDate: z.string().nullable()
+});
+var workerDetailSchema = workerSummarySchema.extend({
+  bindingsCount: z.number().int().nonnegative(),
+  placementMode: z.string().nullable(),
+  logpush: z.boolean()
+});
+var routeSchema = z.object({
+  id: z.string(),
+  pattern: z.string(),
+  script: z.string().nullable(),
+  zoneName: z.string().nullable()
+});
+var accountSummarySchema = z.object({
+  id: z.string(),
+  name: z.string(),
+  type: z.string().nullable()
+});
+var cloudflareResponseSchema = (resultSchema) => z.object({
+  success: z.boolean().optional(),
+  result: resultSchema
+});
+var workerListResponseSchema = cloudflareResponseSchema(
+  z.array(
+    z.object({
+      id: z.string(),
+      created_on: z.string().nullable().optional(),
+      modified_on: z.string().nullable().optional(),
+      usage_model: z.string().nullable().optional(),
+      handlers: z.array(z.string()).optional(),
+      compatibility_date: z.string().nullable().optional()
+    })
+  )
+);
+var workerSettingsResponseSchema = cloudflareResponseSchema(
+  z.object({
+    compatibility_date: z.string().nullable().optional(),
+    usage_model: z.string().nullable().optional(),
+    bindings: z.array(z.unknown()).optional(),
+    placement_mode: z.string().nullable().optional(),
+    logpush: z.boolean().optional()
+  })
+);
+var routesResponseSchema = cloudflareResponseSchema(
+  z.array(
+    z.object({
+      id: z.string(),
+      pattern: z.string(),
+      script: z.string().nullable().optional(),
+      zone_name: z.string().nullable().optional()
+    })
+  )
+);
+var accountResponseSchema = cloudflareResponseSchema(
+  z.object({
+    id: z.string(),
+    name: z.string(),
+    type: z.string().nullable().optional()
+  })
+);
+function resolveEnv(source = process.env) {
+  return loadEnv(envShape, source);
+}
+function toNullableString(value) {
+  return typeof value === "string" && value.length > 0 ? value : null;
+}
+var FetchCloudflareWorkersClient = class {
+  accountId;
+  baseUrl;
+  fetchImpl;
+  headers;
+  constructor(options) {
+    this.accountId = options.accountId;
+    this.baseUrl = (options.baseUrl ?? "https://api.cloudflare.com/client/v4").replace(/\/+$/, "");
+    this.fetchImpl = options.fetch;
+    this.headers = {
+      authorization: `Bearer ${options.apiToken}`,
+      accept: "application/json"
+    };
+  }
+  async listWorkers(limit) {
+    const payload = await this.requestJson(
+      `/accounts/${this.accountId}/workers/scripts`,
+      workerListResponseSchema
+    );
+    return payload.result.slice(0, limit).map((worker) => ({
+      name: worker.id,
+      createdAt: toNullableString(worker.created_on),
+      modifiedAt: toNullableString(worker.modified_on),
+      usageModel: toNullableString(worker.usage_model),
+      handlers: worker.handlers ?? [],
+      compatibilityDate: toNullableString(worker.compatibility_date)
+    }));
+  }
+  async getWorker(scriptName) {
+    const [summary, settings] = await Promise.all([
+      this.listWorkers(Number.MAX_SAFE_INTEGER),
+      this.requestJson(
+        `/accounts/${this.accountId}/workers/scripts/${encodeURIComponent(scriptName)}/settings`,
+        workerSettingsResponseSchema
+      )
+    ]);
+    const worker = summary.find((entry) => entry.name === scriptName);
+    if (!worker) {
+      throw new ExternalServiceError(`Cloudflare worker '${scriptName}' was not found.`, {
+        statusCode: 404
+      });
+    }
+    return {
+      ...worker,
+      bindingsCount: settings.result.bindings?.length ?? 0,
+      placementMode: toNullableString(settings.result.placement_mode),
+      logpush: settings.result.logpush ?? false
+    };
+  }
+  async listRoutes(input) {
+    const payload = await this.requestJson(`/accounts/${this.accountId}/workers/routes`, routesResponseSchema);
+    const filtered = payload.result.filter((route) => input.scriptName === void 0 || route.script === input.scriptName).slice(0, input.limit);
+    return filtered.map((route) => ({
+      id: route.id,
+      pattern: route.pattern,
+      script: toNullableString(route.script),
+      zoneName: toNullableString(route.zone_name)
+    }));
+  }
+  async getAccountSummary() {
+    const payload = await this.requestJson(`/accounts/${this.accountId}`, accountResponseSchema);
+    return {
+      id: payload.result.id,
+      name: payload.result.name,
+      type: toNullableString(payload.result.type)
+    };
+  }
+  async requestJson(path, schema) {
+    const url = new URL(path, this.baseUrl);
+    const response = await this.fetchImpl(url, {
+      method: "GET",
+      headers: this.headers
+    });
+    if (!response.ok) {
+      const body = await response.text();
+      throw new ExternalServiceError(`Cloudflare request failed with status ${response.status}.`, {
+        statusCode: response.status,
+        details: body
+      });
+    }
+    const payload = await response.json();
+    const parsed = schema.safeParse(payload);
+    if (!parsed.success) {
+      throw new ExternalServiceError("Cloudflare returned an unexpected response shape.", {
+        details: parsed.error.flatten()
+      });
+    }
+    return parsed.data;
+  }
+};
+var CloudflareWorkersServer = class extends ToolkitServer {
+  client;
+  constructor(client) {
+    super(metadata);
+    this.client = client;
+    this.registerTool(
+      defineTool({
+        name: "list_workers",
+        title: "List Workers",
+        description: "List worker scripts in the configured Cloudflare account.",
+        inputSchema: {
+          limit: z.number().int().min(1).max(100).default(20)
+        },
+        outputSchema: {
+          workers: z.array(workerSummarySchema),
+          returned: z.number().int()
+        },
+        handler: async ({ limit }, context) => {
+          await context.log("info", "Listing Cloudflare workers");
+          const workers = await this.client.listWorkers(limit);
+          return {
+            workers: [...workers],
+            returned: workers.length
+          };
+        },
+        renderText: ({ workers, returned }) => {
+          if (returned === 0) {
+            return "No Cloudflare workers found.";
+          }
+          return workers.map((worker) => `${worker.name} (${worker.usageModel ?? "standard"})`).join("\n");
+        }
+      })
+    );
+    this.registerTool(
+      defineTool({
+        name: "get_worker",
+        title: "Get worker",
+        description: "Fetch Cloudflare Worker settings for a specific script.",
+        inputSchema: {
+          scriptName: z.string().trim().min(1)
+        },
+        outputSchema: {
+          worker: workerDetailSchema
+        },
+        handler: async ({ scriptName }, context) => {
+          await context.log("info", `Fetching Cloudflare worker ${scriptName}`);
+          return {
+            worker: await this.client.getWorker(scriptName)
+          };
+        },
+        renderText: ({ worker }) => `${worker.name} uses ${worker.bindingsCount} bindings and ${worker.usageModel ?? "default"} mode.`
+      })
+    );
+    this.registerTool(
+      defineTool({
+        name: "list_routes",
+        title: "List worker routes",
+        description: "List routes attached to Cloudflare Workers in the account.",
+        inputSchema: {
+          limit: z.number().int().min(1).max(200).default(50),
+          scriptName: z.string().trim().min(1).optional()
+        },
+        outputSchema: {
+          routes: z.array(routeSchema),
+          returned: z.number().int()
+        },
+        handler: async ({ limit, scriptName }, context) => {
+          await context.log("info", "Listing Cloudflare worker routes");
+          const request = { limit };
+          if (scriptName !== void 0) {
+            request.scriptName = scriptName;
+          }
+          const routes = await this.client.listRoutes(request);
+          return {
+            routes: [...routes],
+            returned: routes.length
+          };
+        },
+        renderText: ({ routes, returned }) => {
+          if (returned === 0) {
+            return "No matching worker routes found.";
+          }
+          return routes.map((route) => `${route.pattern} -> ${route.script ?? "unbound"}`).join("\n");
+        }
+      })
+    );
+    this.registerStaticResource(
+      "account",
+      "cloudflare://account",
+      {
+        title: "Cloudflare account",
+        description: "Cloudflare account summary for the configured Workers account.",
+        mimeType: "application/json"
+      },
+      async (uri) => this.createJsonResource(uri.toString(), await this.client.getAccountSummary())
+    );
+    this.registerPrompt(
+      "edge-rollout",
+      {
+        title: "Edge rollout prompt",
+        description: "Create a rollout checklist for deploying or expanding a Worker.",
+        argsSchema: {
+          scriptName: z.string().trim().min(1),
+          routePattern: z.string().trim().min(1).optional(),
+          rolloutGoal: z.string().trim().min(1)
+        }
+      },
+      async ({ scriptName, routePattern, rolloutGoal }) => this.createTextPrompt(
+        [
+          `Plan a Cloudflare Workers rollout for "${scriptName}" with the goal: ${rolloutGoal}.`,
+          routePattern ? `Include route coverage for ${routePattern}.` : "Include route validation, traffic ramp-up, and rollback checks.",
+          "Call out caching, bindings, observability, and regional blast-radius considerations."
+        ].join(" ")
+      )
+    );
+  }
+};
+async function createServer(options = {}) {
+  if (options.client) {
+    return new CloudflareWorkersServer(options.client);
+  }
+  const env = resolveEnv(options.env);
+  return new CloudflareWorkersServer(
+    new FetchCloudflareWorkersClient({
+      apiToken: env.CLOUDFLARE_API_TOKEN,
+      accountId: env.CLOUDFLARE_ACCOUNT_ID,
+      fetch: options.fetch ?? globalThis.fetch,
+      ...env.CLOUDFLARE_API_BASE_URL ? { baseUrl: env.CLOUDFLARE_API_BASE_URL } : {}
+    })
+  );
+}
+function isMainModule(metaUrl) {
+  const entry = process.argv[1];
+  return typeof entry === "string" && fileURLToPath(metaUrl) === resolve(entry);
+}
+async function main(argv = process.argv.slice(2)) {
+  const runtimeOptions = parseRuntimeOptions(argv);
+  await runToolkitServer(
+    {
+      createServer: () => createServer(),
+      serverCard
+    },
+    runtimeOptions
+  );
+}
+if (isMainModule(import.meta.url)) {
+  await main();
+}
+export {
+  CloudflareWorkersServer,
+  createServer,
+  main,
+  metadata,
+  serverCard
+};

package/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "@universal-mcp-toolkit/server-cloudflare-workers",
+  "version": "0.1.0",
+  "type": "module",
+  "description": "Worker, route, and deployment tools for Cloudflare Workers.",
+  "license": "MIT",
+  "bin": {
+    "server-cloudflare-workers": "./dist/index.js",
+    "umt-cloudflare-workers": "./dist/index.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Markgatcha/universal-mcp-toolkit.git"
+  },
+  "homepage": "https://github.com/Markgatcha/universal-mcp-toolkit#readme",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist",
+    ".well-known"
+  ],
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "ai",
+    "developer-tools",
+    "typescript",
+    "cloudflare",
+    "workers",
+    "edge",
+    "deployments"
+  ],
+  "dependencies": {
+    "@universal-mcp-toolkit/core": "0.1.0",
+    "zod": "^4.3.6"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --format esm --dts --clean",
+    "dev": "tsx watch src/index.ts",
+    "lint": "tsc --noEmit",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run --passWithNoTests",
+    "clean": "rimraf dist"
+  }
+}