deploy-mcp 0.5.0 → 0.6.0

package/README.md

@@ -8,6 +8,7 @@ Track deployments across all platforms directly in your AI conversation.
 No more context-switching. No more dashboard hunting.
 
 [![npm version](https://img.shields.io/npm/v/deploy-mcp.svg?style=for-the-badge&color=ff6b6b)](https://www.npmjs.com/package/deploy-mcp)
+[![npm downloads](https://img.shields.io/npm/dm/deploy-mcp.svg?style=for-the-badge&color=00d2d3)](https://www.npmjs.com/package/deploy-mcp)
 [![License](https://img.shields.io/badge/license-Apache%202.0-blue.svg?style=for-the-badge)](https://github.com/alexpota/deploy-mcp/blob/main/LICENSE)
 [![Website](https://img.shields.io/badge/website-deploy--mcp.io-ff8e53?style=for-the-badge)](https://deploy-mcp.io)
 
@@ -16,34 +17,22 @@ No more context-switching. No more dashboard hunting.
 ---
 
 ## Demo
-─────────────────────────
 
-### Your conversation:
-```
-User: "Check my latest Vercel deployment"
-```
+<div align="center">
+  
+  <kbd>
+    <a href="./assets/demo.gif">
+      <img src="./assets/demo-preview.png" alt="Click to watch full demo" width="600" />
+    </a>
+  </kbd>
+  
+  <br /><br />
+  
+  <sub>**[Watch Full Demo](./assets/demo.gif)** · **[Live Badge Demo](https://mcp-netlify-demo.netlify.app/)**</sub>
+  
+</div>
 
-### AI Assistant's Response:
-
-> ## Deployment Status
-> 
-> ### Current Status
-> **Project:** my-app  
-> **Platform:** Vercel  
-> **Status:** ✅ Success  
-> **URL:** https://my-app.vercel.app  
-> **Duration:** 45s  
-> **Deployed:** 2 hours ago  
-> 
-> ### Commit Info
-> **SHA:** `abc123ef`  
-> **Message:** Update homepage hero section  
-> **Author:** John Doe  
-> 
-> Everything looks good - your deployment is live and running successfully!
-
-**Just ask your AI**: *"What's the status of my latest deployment?"*  
-Get instant answers without leaving your conversation.
+---
 
 ## Quick Start
 ─────────────────────────
@@ -65,8 +54,8 @@ deploy-mcp supports multiple deployment platforms simultaneously. Configure as m
 |----------|--------|---------------|----------|
 | **Vercel** | ✅ Ready | `VERCEL_TOKEN` | Status, Logs, History, Real-time Monitoring |
 | **Netlify** | ✅ Ready | `NETLIFY_TOKEN` | Status, Logs, History, Real-time Monitoring |
-| **Railway** | Coming Soon | `RAILWAY_TOKEN` | - |
-| **Render** | Coming Soon | `RENDER_TOKEN` | - |
+| **Cloudflare Pages** | ✅ Ready | `CLOUDFLARE_TOKEN` | Status, Logs, History, Real-time Monitoring |
+| **GitHub Pages** | 🚧 Coming Soon | `GITHUB_TOKEN` | - |
 
 ### Multi-Platform Configuration
 
@@ -80,7 +69,8 @@ You can use **multiple platforms simultaneously** by providing tokens for each p
       "args": ["-y", "deploy-mcp"],
       "env": {
         "VERCEL_TOKEN": "your-vercel-token",
-        "NETLIFY_TOKEN": "your-netlify-token"
+        "NETLIFY_TOKEN": "your-netlify-token",
+        "CLOUDFLARE_TOKEN": "accountId:globalApiKey"
         // Add more platform tokens as needed
       }
     }
@@ -155,6 +145,46 @@ You can use **multiple platforms simultaneously** by providing tokens for each p
 
 </details>
 
+### Cloudflare Pages
+
+<details>
+<summary><strong>Setup Instructions</strong></summary>
+
+1. **Get your API token:**
+   - Go to [dash.cloudflare.com/profile/api-tokens](https://dash.cloudflare.com/profile/api-tokens)
+   - Click "Create Token"
+   - Use "Custom token" with these permissions:
+     - **Zone:Zone:Read**
+     - **Zone:Page Rules:Read**
+     - **Account:Cloudflare Pages:Edit**
+   - Or use your Global API Key (format: `accountId:globalApiKey`)
+   - Copy the token
+
+2. **Add to your AI assistant configuration:**
+   ```json
+   {
+     "env": {
+       "CLOUDFLARE_TOKEN": "your-cloudflare-token-or-accountId:globalApiKey"
+     }
+   }
+   ```
+
+3. **Available commands:**
+   - `"Check my Cloudflare Pages deployment for project-name"`
+   - `"What's the status of my latest Cloudflare Pages deployment?"`
+   - `"Show me Cloudflare Pages deployment logs"`
+   - `"Watch my Cloudflare Pages deployment progress"`
+   - `"List all my Cloudflare Pages projects"`
+   - `"Show deployment history for project-name"`
+
+4. **Token formats supported:**
+   - **API Token**: `your-api-token` (requires `CLOUDFLARE_ACCOUNT_ID` env var)
+   - **Global API Key**: `accountId:globalApiKey` (all-in-one format)
+
+5. **Required permissions:** Account access to Cloudflare Pages
+
+</details>
+
 ## AI Assistant Configuration
 ─────────────────────────
 

package/dist/{chunk-YU5SU5ZI.js → chunk-BFOEFRRT.js}

@@ -1,6 +1,6 @@
 // src/core/tools.ts
 import { z } from "zod";
-var SUPPORTED_PLATFORMS = ["vercel", "netlify"];
+var SUPPORTED_PLATFORMS = ["vercel", "netlify", "cloudflare-pages"];
 var checkDeploymentStatusSchema = z.object({
   platform: z.enum(SUPPORTED_PLATFORMS).describe("The deployment platform"),
   project: z.string().describe("The project name or ID"),
@@ -57,7 +57,7 @@ var tools = [
       properties: {
         platform: {
           type: "string",
-          enum: ["vercel", "netlify"],
+          enum: SUPPORTED_PLATFORMS,
           description: "The deployment platform"
         },
         project: {
@@ -87,7 +87,7 @@ var tools = [
       properties: {
         platform: {
           type: "string",
-          enum: ["vercel", "netlify"],
+          enum: SUPPORTED_PLATFORMS,
           description: "The deployment platform"
         },
         project: {
@@ -114,7 +114,7 @@ var tools = [
       properties: {
         platform: {
           type: "string",
-          enum: ["vercel", "netlify"],
+          enum: SUPPORTED_PLATFORMS,
           description: "The deployment platform"
         },
         project: {
@@ -165,7 +165,7 @@ var tools = [
       properties: {
         platform: {
           type: "string",
-          enum: ["vercel", "netlify"],
+          enum: SUPPORTED_PLATFORMS,
           description: "The deployment platform"
         },
         deploymentId: {
@@ -198,7 +198,7 @@ var tools = [
       properties: {
         platform: {
           type: "string",
-          enum: ["vercel", "netlify"],
+          enum: SUPPORTED_PLATFORMS,
           description: "The deployment platform"
         },
         limit: {
@@ -351,6 +351,7 @@ var API_PARAMS = {
 };
 var API_CONFIG = {
   VERCEL_BASE_URL: "https://api.vercel.com",
+  CLOUDFLARE_BASE_URL: "https://api.cloudflare.com/client/v4",
   DEFAULT_TIMEOUT_MS: 1e4,
   DEFAULT_RETRY_ATTEMPTS: 3,
   DEFAULT_DEPLOYMENT_LIMIT: 10,
@@ -359,8 +360,8 @@ var API_CONFIG = {
 var PLATFORM = {
   VERCEL: "vercel",
   NETLIFY: "netlify",
-  RAILWAY: "railway",
-  RENDER: "render"
+  CLOUDFLARE_PAGES: "cloudflare-pages",
+  GITHUB_PAGES: "github-pages"
 };
 var ENVIRONMENT_TYPES = {
   PRODUCTION: "production",
@@ -392,10 +393,21 @@ var NETLIFY_STATES = {
   ERROR: "error",
   RETRYING: "retrying"
 };
+var CLOUDFLARE_PAGES_STATES = {
+  ACTIVE: "active",
+  SUCCESS: "success",
+  FAILED: "failed",
+  CANCELED: "canceled",
+  SKIPPED: "skipped"
+};
 var ADAPTER_ERRORS = {
-  TOKEN_REQUIRED: "Vercel token required. Set VERCEL_TOKEN environment variable or pass token parameter.",
-  FETCH_DEPLOYMENT_FAILED: "Failed to fetch deployment status from Vercel",
-  UNKNOWN_STATUS: "unknown"
+  TOKEN_REQUIRED: "API token required. Set appropriate environment variable or pass token parameter.",
+  VERCEL_TOKEN_REQUIRED: "Vercel token required. Set VERCEL_TOKEN environment variable or pass token parameter.",
+  NETLIFY_TOKEN_REQUIRED: "Netlify token required. Set NETLIFY_TOKEN environment variable or pass token parameter.",
+  CLOUDFLARE_TOKEN_REQUIRED: "Cloudflare token required. Set CLOUDFLARE_TOKEN environment variable or pass token parameter.",
+  FETCH_DEPLOYMENT_FAILED: "Failed to fetch deployment status",
+  UNKNOWN_STATUS: "unknown",
+  CLOUDFLARE_ACCOUNT_ID_REQUIRED: "Cloudflare account ID required. Provide as 'accountId:apiToken' or set CLOUDFLARE_ACCOUNT_ID"
 };
 
 // src/adapters/base/api-client.ts
@@ -811,7 +823,7 @@ var VercelAdapter = class extends BaseAdapter {
   async getLatestDeployment(project, token) {
     const apiToken = token || process.env.VERCEL_TOKEN;
     if (!apiToken) {
-      throw new Error(ADAPTER_ERRORS.TOKEN_REQUIRED);
+      throw new Error(ADAPTER_ERRORS.VERCEL_TOKEN_REQUIRED);
     }
     try {
       const data = await this.api.getDeployments(
@@ -1190,6 +1202,404 @@ var NetlifyAdapter = class extends BaseAdapter {
   }
 };
 
+// src/adapters/cloudflare-pages/endpoints.ts
+var CloudflarePagesEndpoints = {
+  // Base URL
+  base: "https://api.cloudflare.com/client/v4",
+  // Projects
+  listProjects: (accountId) => `/accounts/${accountId}/pages/projects`,
+  getProject: (accountId, projectName) => `/accounts/${accountId}/pages/projects/${projectName}`,
+  // Deployments
+  listDeployments: (accountId, projectName) => `/accounts/${accountId}/pages/projects/${projectName}/deployments`,
+  getDeployment: (accountId, projectName, deploymentId) => `/accounts/${accountId}/pages/projects/${projectName}/deployments/${deploymentId}`,
+  createDeployment: (accountId, projectName) => `/accounts/${accountId}/pages/projects/${projectName}/deployments`,
+  deleteDeployment: (accountId, projectName, deploymentId) => `/accounts/${accountId}/pages/projects/${projectName}/deployments/${deploymentId}`,
+  retryDeployment: (accountId, projectName, deploymentId) => `/accounts/${accountId}/pages/projects/${projectName}/deployments/${deploymentId}/retry`,
+  rollbackDeployment: (accountId, projectName, deploymentId) => `/accounts/${accountId}/pages/projects/${projectName}/deployments/${deploymentId}/rollback`,
+  // Logs
+  getDeploymentLogs: (accountId, projectName, deploymentId) => `/accounts/${accountId}/pages/projects/${projectName}/deployments/${deploymentId}/history/logs`,
+  // Documentation URLs
+  docs: {
+    api: "https://developers.cloudflare.com/api/resources/pages/",
+    gettingStarted: "https://developers.cloudflare.com/pages/get-started/",
+    authentication: "https://developers.cloudflare.com/fundamentals/api/get-started/create-token/",
+    deployments: "https://developers.cloudflare.com/pages/configuration/deployments/",
+    buildConfiguration: "https://developers.cloudflare.com/pages/configuration/build-configuration/"
+  }
+};
+
+// src/adapters/cloudflare-pages/api.ts
+var CloudflarePagesAPI = class extends BaseAPIClient {
+  accountId;
+  apiToken;
+  endpoints = {
+    listProjects: {
+      path: "",
+      // Will be set dynamically
+      method: "GET",
+      docsUrl: CloudflarePagesEndpoints.docs.api,
+      description: "List all Cloudflare Pages projects"
+    },
+    getProject: {
+      path: "pages/projects/{projectName}",
+      method: "GET",
+      docsUrl: CloudflarePagesEndpoints.docs.api,
+      description: "Get details for a specific project"
+    },
+    listDeployments: {
+      path: "pages/projects/{projectName}/deployments",
+      method: "GET",
+      docsUrl: CloudflarePagesEndpoints.docs.deployments,
+      description: "List deployments for a project"
+    },
+    getDeployment: {
+      path: "pages/projects/{projectName}/deployments/{deploymentId}",
+      method: "GET",
+      docsUrl: CloudflarePagesEndpoints.docs.deployments,
+      description: "Get details for a specific deployment"
+    },
+    getDeploymentLogs: {
+      path: "pages/projects/{projectName}/deployments/{deploymentId}/history/logs",
+      method: "GET",
+      docsUrl: CloudflarePagesEndpoints.docs.deployments,
+      description: "Get logs for a deployment"
+    },
+    createDeployment: {
+      path: "pages/projects/{projectName}/deployments",
+      method: "POST",
+      docsUrl: CloudflarePagesEndpoints.docs.deployments,
+      description: "Create a new deployment"
+    },
+    retryDeployment: {
+      path: "pages/projects/{projectName}/deployments/{deploymentId}/retry",
+      method: "POST",
+      docsUrl: CloudflarePagesEndpoints.docs.deployments,
+      description: "Retry a failed deployment"
+    }
+  };
+  constructor(accountId, apiToken) {
+    super({
+      baseUrl: CloudflarePagesEndpoints.base,
+      headers: {
+        Authorization: `Bearer ${apiToken}`
+      },
+      timeout: 3e4,
+      retry: 3
+    });
+    this.accountId = accountId;
+    this.apiToken = apiToken;
+  }
+  cleanPath(path) {
+    return path.startsWith("/") ? path.slice(1) : path;
+  }
+  async listProjects(options) {
+    const endpoint = this.endpoints.listProjects;
+    const path = this.cleanPath(
+      CloudflarePagesEndpoints.listProjects(this.accountId)
+    );
+    const response = await this.request(
+      { ...endpoint, path },
+      {
+        searchParams: options?.page || options?.perPage ? {
+          ...options.page && { page: options.page },
+          ...options.perPage && { per_page: options.perPage }
+        } : void 0,
+        token: this.apiToken
+      }
+    );
+    if (!response.success) {
+      throw new Error(
+        `Failed to list projects: ${response.errors?.[0]?.message || "Unknown error"}`
+      );
+    }
+    return response.result;
+  }
+  async getProject(projectName) {
+    const endpoint = this.endpoints.getProject;
+    const path = this.cleanPath(
+      CloudflarePagesEndpoints.getProject(this.accountId, projectName)
+    );
+    const response = await this.request(
+      { ...endpoint, path },
+      { token: this.apiToken }
+    );
+    if (!response.success) {
+      throw new Error(
+        `Failed to get project ${projectName}: ${response.errors?.[0]?.message || "Unknown error"}`
+      );
+    }
+    return response.result;
+  }
+  async listDeployments(projectName, options) {
+    const endpoint = this.endpoints.listDeployments;
+    const path = this.cleanPath(
+      CloudflarePagesEndpoints.listDeployments(this.accountId, projectName)
+    );
+    const searchParams = {};
+    if (options?.page) {
+      searchParams.page = options.page;
+    }
+    if (options?.perPage) {
+      searchParams.per_page = options.perPage;
+    }
+    if (options?.environment) {
+      searchParams.env = options.environment;
+    }
+    const response = await this.request(
+      { ...endpoint, path },
+      {
+        searchParams,
+        token: this.apiToken
+      }
+    );
+    if (!response.success) {
+      throw new Error(
+        `Failed to list deployments for ${projectName}: ${response.errors?.[0]?.message || "Unknown error"}`
+      );
+    }
+    return response.result;
+  }
+  async getDeployment(projectName, deploymentId) {
+    const endpoint = this.endpoints.getDeployment;
+    const path = this.cleanPath(
+      CloudflarePagesEndpoints.getDeployment(
+        this.accountId,
+        projectName,
+        deploymentId
+      )
+    );
+    const response = await this.request(
+      { ...endpoint, path },
+      { token: this.apiToken }
+    );
+    if (!response.success) {
+      throw new Error(
+        `Failed to get deployment ${deploymentId}: ${response.errors?.[0]?.message || "Unknown error"}`
+      );
+    }
+    return response.result;
+  }
+  async getLatestDeployment(projectName, environment = "production") {
+    const deployments = await this.listDeployments(projectName, {
+      environment
+    });
+    return deployments[0] || null;
+  }
+  async getDeploymentLogs(projectName, deploymentId) {
+    const endpoint = this.endpoints.getDeploymentLogs;
+    const path = this.cleanPath(
+      CloudflarePagesEndpoints.getDeploymentLogs(
+        this.accountId,
+        projectName,
+        deploymentId
+      )
+    );
+    const response = await this.request(
+      { ...endpoint, path },
+      { token: this.apiToken }
+    );
+    if (!response.success) {
+      throw new Error(
+        `Failed to get deployment logs: ${response.errors?.[0]?.message || "Unknown error"}`
+      );
+    }
+    return response;
+  }
+  async createDeployment(projectName, branch) {
+    const endpoint = this.endpoints.createDeployment;
+    const path = this.cleanPath(
+      CloudflarePagesEndpoints.createDeployment(this.accountId, projectName)
+    );
+    const body = branch ? { branch } : {};
+    const response = await this.request(
+      { ...endpoint, path },
+      {
+        body,
+        token: this.apiToken
+      }
+    );
+    if (!response.success) {
+      throw new Error(
+        `Failed to create deployment: ${response.errors?.[0]?.message || "Unknown error"}`
+      );
+    }
+    return response.result;
+  }
+  async retryDeployment(projectName, deploymentId) {
+    const endpoint = this.endpoints.retryDeployment;
+    const path = this.cleanPath(
+      CloudflarePagesEndpoints.retryDeployment(
+        this.accountId,
+        projectName,
+        deploymentId
+      )
+    );
+    const response = await this.request(
+      { ...endpoint, path },
+      { token: this.apiToken }
+    );
+    if (!response.success) {
+      throw new Error(
+        `Failed to retry deployment: ${response.errors?.[0]?.message || "Unknown error"}`
+      );
+    }
+    return response.result;
+  }
+};
+
+// src/adapters/cloudflare-pages/index.ts
+var CloudflarePagesAdapter = class extends BaseAdapter {
+  name = "cloudflare-pages";
+  api = null;
+  getAPI(token) {
+    let accountId;
+    let apiToken;
+    if (token.includes(":")) {
+      [accountId, apiToken] = token.split(":", 2);
+    } else {
+      accountId = process.env.CLOUDFLARE_ACCOUNT_ID || "";
+      apiToken = token;
+    }
+    if (!accountId) {
+      throw new Error(
+        "Cloudflare account ID is required. Provide it as 'accountId:apiToken' or set CLOUDFLARE_ACCOUNT_ID environment variable"
+      );
+    }
+    if (!this.api || this.api["accountId"] !== accountId) {
+      this.api = new CloudflarePagesAPI(accountId, apiToken);
+    }
+    return this.api;
+  }
+  async getLatestDeployment(project, token) {
+    const apiToken = token || process.env.CLOUDFLARE_TOKEN || process.env.CLOUDFLARE_API_TOKEN;
+    if (!apiToken) {
+      throw new Error("Cloudflare API token is required");
+    }
+    try {
+      const api = this.getAPI(apiToken);
+      const deployment = await api.getLatestDeployment(project);
+      if (!deployment) {
+        return {
+          status: "unknown",
+          projectName: project,
+          platform: "cloudflare-pages"
+        };
+      }
+      return this.transformDeployment(deployment);
+    } catch (error) {
+      if (error instanceof Error) {
+        throw error;
+      }
+      throw new Error(`Failed to fetch deployment: ${error}`);
+    }
+  }
+  async authenticate(token) {
+    try {
+      const api = this.getAPI(token);
+      await api.listProjects({ perPage: 1 });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async getDeploymentById(deploymentId, token) {
+    if (!deploymentId.includes(":")) {
+      throw new Error(
+        "Deployment ID must be in format 'projectName:deploymentId' for Cloudflare Pages"
+      );
+    }
+    const [projectName, actualDeploymentId] = deploymentId.split(":", 2);
+    const api = this.getAPI(token);
+    return api.getDeployment(projectName, actualDeploymentId);
+  }
+  async getRecentDeployments(project, token, _limit = 10) {
+    const api = this.getAPI(token);
+    return api.listDeployments(project);
+  }
+  async getDeploymentLogs(deploymentId, token) {
+    if (!deploymentId.includes(":")) {
+      throw new Error(
+        "Deployment ID must be in format 'projectName:deploymentId' for Cloudflare Pages"
+      );
+    }
+    const [projectName, actualDeploymentId] = deploymentId.split(":", 2);
+    const api = this.getAPI(token);
+    const response = await api.getDeploymentLogs(
+      projectName,
+      actualDeploymentId
+    );
+    if (!response.result?.data || response.result.data.length === 0) {
+      return "No logs available";
+    }
+    return response.result.data.map(
+      (log) => `[${log.timestamp}] ${log.level.toUpperCase()}: ${log.message}`
+    ).join("\n");
+  }
+  async listProjects(token, _limit = 20) {
+    const api = this.getAPI(token);
+    const projects = await api.listProjects();
+    return projects.map((project) => ({
+      id: project.id,
+      name: project.name,
+      url: project.domains?.[0] ? `https://${project.domains[0]}` : `https://${project.subdomain}.pages.dev`
+    }));
+  }
+  transformDeployment(deployment) {
+    const status = this.mapStageStatus(deployment.latest_stage?.status);
+    return {
+      id: deployment.id,
+      status,
+      url: deployment.url,
+      projectName: deployment.project_name,
+      platform: "cloudflare-pages",
+      timestamp: this.formatTimestamp(deployment.created_on),
+      duration: deployment.latest_stage ? this.calculateDuration(
+        deployment.latest_stage.started_on || deployment.created_on,
+        deployment.latest_stage.ended_on || void 0
+      ) : void 0,
+      environment: deployment.environment,
+      commit: deployment.source?.config ? {
+        sha: deployment.source.config.commit_hash,
+        message: deployment.source.config.commit_message,
+        author: void 0
+        // Cloudflare Pages doesn't provide author in API
+      } : void 0
+    };
+  }
+  mapStageStatus(status) {
+    if (!status) {
+      return "unknown";
+    }
+    switch (status) {
+      case "success":
+        return "success";
+      case "failed":
+      case "canceled":
+        return "failed";
+      case "active":
+        return "building";
+      case "skipped":
+        return "unknown";
+      default:
+        return "unknown";
+    }
+  }
+  // Helper method to get deployment status
+  async getDeploymentStatus(project, token) {
+    return this.getLatestDeployment(project, token);
+  }
+  // Helper method to trigger a new deployment
+  async triggerDeployment(project, token, branch) {
+    const api = this.getAPI(token);
+    return api.createDeployment(project, branch);
+  }
+  // Helper method to retry a failed deployment
+  async retryDeployment(projectName, deploymentId, token) {
+    const api = this.getAPI(token);
+    return api.retryDeployment(projectName, deploymentId);
+  }
+};
+
 // src/core/deployment-intelligence.ts
 var DeploymentIntelligence = class {
   adapter;
@@ -1204,10 +1614,8 @@ var DeploymentIntelligence = class {
         return process.env.VERCEL_TOKEN;
       case "netlify":
         return process.env.NETLIFY_TOKEN;
-      case "railway":
-        return process.env.RAILWAY_TOKEN;
-      case "render":
-        return process.env.RENDER_TOKEN;
+      case "cloudflare-pages":
+        return process.env.CLOUDFLARE_TOKEN;
       default:
         return void 0;
     }
@@ -1248,11 +1656,11 @@ var DeploymentIntelligence = class {
         return new VercelAdapter();
       case "netlify":
         return new NetlifyAdapter();
+      case "cloudflare-pages":
+        return new CloudflarePagesAdapter();
       // Ready for future platforms
-      // case "railway":
-      //   return new RailwayAdapter();
-      // case "render":
-      //   return new RenderAdapter();
+      // case "github-pages":
+      //   return new GitHubPagesAdapter();
       default:
         throw new Error(`Unsupported platform: ${platform}`);
     }
@@ -2050,9 +2458,12 @@ var MCPHandler = class {
         const formattedStatus = this.formatResponse(status, validated.platform);
         return ResponseFormatter.formatStatus(formattedStatus);
       } else {
+        const tokenEnvKey = `${validated.platform.toUpperCase().replace(/-/g, "_")}_TOKEN`;
+        const generalTokenKey = validated.platform.startsWith("cloudflare-") ? "CLOUDFLARE_TOKEN" : validated.platform.startsWith("github-") ? "GITHUB_TOKEN" : null;
+        const token = validated.token || process.env[tokenEnvKey] || (generalTokenKey ? process.env[generalTokenKey] : null) || "";
         const deployments = await adapter.getRecentDeployments(
           validated.project,
-          validated.token || process.env[`${validated.platform.toUpperCase()}_TOKEN`] || "",
+          token,
           validated.limit
         );
         if (deployments.length === 0) {
@@ -2108,6 +2519,27 @@ var MCPHandler = class {
           author: deployment.committer
         } : void 0
       };
+    } else if (platform === PLATFORM.CLOUDFLARE_PAGES) {
+      return {
+        id: deployment.id,
+        status: this.mapCloudflareState(
+          deployment.latest_stage?.status || "unknown"
+        ),
+        url: deployment.url,
+        projectName: deployment.project_name,
+        platform,
+        timestamp: deployment.created_on,
+        duration: deployment.latest_stage?.ended_on && deployment.latest_stage?.started_on ? Math.floor(
+          (new Date(deployment.latest_stage.ended_on).getTime() - new Date(deployment.latest_stage.started_on).getTime()) / 1e3
+        ) : void 0,
+        environment: deployment.environment || "production",
+        commit: deployment.source?.config ? {
+          sha: deployment.source.config.commit_hash,
+          message: deployment.source.config.commit_message,
+          author: void 0
+          // Cloudflare doesn't provide author
+        } : void 0
+      };
     }
     return deployment;
   }
@@ -2138,6 +2570,21 @@ var MCPHandler = class {
         return "building";
     }
   }
+  mapCloudflareState(state) {
+    switch (state) {
+      case CLOUDFLARE_PAGES_STATES.SUCCESS:
+        return "success";
+      case CLOUDFLARE_PAGES_STATES.FAILED:
+      case CLOUDFLARE_PAGES_STATES.CANCELED:
+        return "failed";
+      case CLOUDFLARE_PAGES_STATES.ACTIVE:
+        return "building";
+      case CLOUDFLARE_PAGES_STATES.SKIPPED:
+        return "unknown";
+      default:
+        return "unknown";
+    }
+  }
   formatResponse(status, platform) {
     return {
       ...status,
@@ -2217,11 +2664,13 @@ ${messages.join("\n\n")}
     if (!adapter) {
       throw new Error(`Unsupported platform: ${validated.platform}`);
     }
-    const tokenEnvKey = `${validated.platform.toUpperCase()}_TOKEN`;
-    const token = validated.token || process.env[tokenEnvKey];
+    const tokenEnvKey = `${validated.platform.toUpperCase().replace(/-/g, "_")}_TOKEN`;
+    const generalTokenKey = validated.platform.startsWith("cloudflare-") ? "CLOUDFLARE_TOKEN" : validated.platform.startsWith("github-") ? "GITHUB_TOKEN" : null;
+    const token = validated.token || process.env[tokenEnvKey] || (generalTokenKey ? process.env[generalTokenKey] : null);
     if (!token) {
+      const tokenOptions = generalTokenKey ? `${tokenEnvKey} or ${generalTokenKey} environment variable` : `${tokenEnvKey} environment variable`;
       throw new Error(
-        `Authentication required. Please provide a token or set ${tokenEnvKey} environment variable.`
+        `Authentication required. Please provide a token or set ${tokenOptions}.`
       );
     }
     try {
@@ -2280,5 +2729,6 @@ export {
   tools,
   VercelAdapter,
   NetlifyAdapter,
+  CloudflarePagesAdapter,
   MCPHandler
 };

package/dist/index.js

@@ -1,10 +1,11 @@
 #!/usr/bin/env node
 import {
+  CloudflarePagesAdapter,
   MCPHandler,
   NetlifyAdapter,
   VercelAdapter,
   tools
-} from "./chunk-YU5SU5ZI.js";
+} from "./chunk-BFOEFRRT.js";
 
 // src/index.ts
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
@@ -16,7 +17,8 @@ import {
 var handler = new MCPHandler(
   /* @__PURE__ */ new Map([
     ["vercel", new VercelAdapter()],
-    ["netlify", new NetlifyAdapter()]
+    ["netlify", new NetlifyAdapter()],
+    ["cloudflare-pages", new CloudflarePagesAdapter()]
   ])
 );
 var server = new Server(

package/dist/worker.js

@@ -1,7 +1,7 @@
 import {
   MCPHandler,
   VercelAdapter
-} from "./chunk-YU5SU5ZI.js";
+} from "./chunk-BFOEFRRT.js";
 
 // src/utils/github.ts
 async function validateRepository(user, repo) {
@@ -32,7 +32,7 @@ async function validateRepository(user, repo) {
 }
 function validateParams(user, repo, platform) {
   const validName = /^[a-zA-Z0-9._-]+$/;
-  const validPlatforms = ["vercel", "netlify", "railway"];
+  const validPlatforms = ["vercel", "netlify", "cloudflare-pages"];
   return validName.test(user) && validName.test(repo) && validPlatforms.includes(platform);
 }
 
@@ -53,9 +53,9 @@ var PLATFORM_CONFIG = {
     label: "Netlify",
     logo: "netlify"
   },
-  railway: {
-    label: "Railway",
-    logo: "railway"
+  "cloudflare-pages": {
+    label: "Cloudflare Pages",
+    logo: "cloudflare"
   }
 };
 function validateParams2(user, repo, platform) {
@@ -651,23 +651,23 @@ var landingPageHTML = `<!DOCTYPE html>
           </p>
         </div>
 
-        <div class="platform">
+        <div class="platform active">
           <div class="platform-header">
-            <span class="platform-name">Railway</span>
-            <span class="platform-status soon">Soon</span>
+            <span class="platform-name">Cloudflare Pages</span>
+            <span class="platform-status">Ready</span>
           </div>
           <p class="platform-desc">
-            Railway integration with service monitoring coming next.
+            Fast edge deployments with free bandwidth and global CDN.
           </p>
         </div>
 
         <div class="platform">
           <div class="platform-header">
-            <span class="platform-name">Render</span>
+            <span class="platform-name">GitHub Pages</span>
             <span class="platform-status soon">Soon</span>
           </div>
           <p class="platform-desc">
-            Render support with service and database monitoring planned.
+            Direct GitHub integration with Actions-based deployment tracking.
           </p>
         </div>
       </div>
@@ -680,7 +680,8 @@ var landingPageHTML = `<!DOCTYPE html>
           <pre style="margin: 0;">{
   "env": {
     "VERCEL_TOKEN": "your-vercel-token",
-    "NETLIFY_TOKEN": "your-netlify-token"
+    "NETLIFY_TOKEN": "your-netlify-token",
+    "CLOUDFLARE_TOKEN": "accountId:globalApiKey"
   }
 }</pre>
         </div>
@@ -767,7 +768,8 @@ var landingPageHTML = `<!DOCTYPE html>
       "args": ["-y", "deploy-mcp"],
       "env": {
         "VERCEL_TOKEN": "your-vercel-token",
-        "NETLIFY_TOKEN": "your-netlify-token"
+        "NETLIFY_TOKEN": "your-netlify-token",
+        "CLOUDFLARE_TOKEN": "accountId:globalApiKey"
       }
     }
   }
@@ -822,7 +824,7 @@ var landingPageHTML = `<!DOCTYPE html>
         <div class="badge-examples">
           <img src="https://img.shields.io/badge/vercel-success-22c55e" alt="Vercel Status">
           <img src="https://img.shields.io/badge/netlify-building-FCD34D" alt="Netlify Status">
-          <img src="https://img.shields.io/badge/railway-coming%20soon-gray" alt="Railway Status">
+          <img src="https://img.shields.io/badge/cloudflare%20pages-ready-22c55e" alt="Cloudflare Pages Status">
         </div>
 
         <div class="badge-code">
@@ -875,7 +877,8 @@ var landingPageHTML = `<!DOCTYPE html>
             args: ['-y', 'deploy-mcp'],
             env: {
               VERCEL_TOKEN: 'your-vercel-token',
-              NETLIFY_TOKEN: 'your-netlify-token'
+              NETLIFY_TOKEN: 'your-netlify-token',
+              CLOUDFLARE_TOKEN: 'accountId:globalApiKey'
             }
           }
         }
@@ -887,7 +890,8 @@ var landingPageHTML = `<!DOCTYPE html>
       const config = JSON.stringify({
         env: {
           VERCEL_TOKEN: 'your-vercel-token',
-          NETLIFY_TOKEN: 'your-netlify-token'
+          NETLIFY_TOKEN: 'your-netlify-token',
+          CLOUDFLARE_TOKEN: 'accountId:globalApiKey'
         }
       }, null, 2);
       copyToClipboard(config, event);
@@ -932,6 +936,9 @@ async function validateWebhookSignature(request, platform, env) {
       return false;
     }
   }
+  if (platform === "cloudflare-pages") {
+    return true;
+  }
   return true;
 }
 function mapDeploymentStatus(platform, payload) {
@@ -964,8 +971,22 @@ function mapDeploymentStatus(platform, payload) {
           return "unknown";
       }
     }
-    case "railway":
-      return "unknown";
+    case "cloudflare-pages": {
+      const cloudflarePagesPayload = payload;
+      switch (cloudflarePagesPayload.status) {
+        case "success":
+          return "success";
+        case "failed":
+        case "canceled":
+          return "failed";
+        case "active":
+          return "building";
+        case "skipped":
+          return "unknown";
+        default:
+          return "unknown";
+      }
+    }
     default:
       return "unknown";
   }

package/package.json

@@ -1,17 +1,19 @@
 {
   "name": "deploy-mcp",
-  "version": "0.5.0",
+  "version": "0.6.0",
   "description": "Universal deployment tracker for AI assistants",
   "keywords": [
     "mcp",
     "deployment",
     "vercel",
     "netlify",
+    "cloudflare-pages",
     "ai",
     "claude",
     "deployment-tracking",
     "netlify-deployment",
     "vercel-deployment",
+    "cloudflare-deployment",
     "deployment-status",
     "deployment-monitor",
     "ci-cd"