@sebastienrousseau/cloudcdn-mcp 0.1.1

package/lib/tools/core.js

@@ -0,0 +1,109 @@
+/**
+ * Core control-plane MCP tools — zones, domains, edge rules, account stats.
+ * AccountKey auth on every call.
+ *
+ * @module @sebastienrousseau/cloudcdn-mcp/lib/tools/core
+ */
+
+import { z } from 'zod';
+import * as api from '../api-client.js';
+
+/**
+ * Register the core tools (`statistics_summary`, `zone_*`, `domain_add`,
+ * `rules_*`) on the given MCP server.
+ *
+ * @param {{ tool: Function }} server - The MCP server instance.
+ * @returns {void}
+ */
+export function registerCoreTools(server) {
+  server.tool(
+    'statistics_summary',
+    'Control-plane statistics: total zones, total files, total storage size, aggregate request volume, last sync timestamp. The control-plane counterpart to `insights_summary` (which is observability data); this answers "what does the account look like right now".',
+    {},
+    async () => {
+      const res = await api.get('/api/core/statistics', { auth: 'account' });
+      return { content: [{ type: 'text', text: JSON.stringify(res.data, null, 2) }] };
+    }
+  );
+
+  server.tool(
+    'zone_list',
+    'List all CDN zones (tenant namespaces) with file counts, storage usage, and categories.',
+    {},
+    async () => {
+      const res = await api.get('/api/core/zones', { auth: 'account' });
+      return { content: [{ type: 'text', text: JSON.stringify(res.data, null, 2) }] };
+    }
+  );
+
+  server.tool(
+    'zone_get',
+    'Get detailed information about a specific zone including all files, categories, formats, and storage usage.',
+    { zone_id: z.string().describe('Zone identifier (e.g., "akande", "bankingonai")') },
+    async ({ zone_id }) => {
+      const res = await api.get(`/api/core/zones/${zone_id}`, { auth: 'account' });
+      return { content: [{ type: 'text', text: JSON.stringify(res.data, null, 2) }] };
+    }
+  );
+
+  server.tool(
+    'zone_create',
+    'Create a new CDN zone with standard v1/ directory scaffolding (banners, github, icons, logos, titles). Committed via Git.',
+    {
+      name: z.string()
+        .min(2).max(64)
+        .regex(/^[a-z0-9][a-z0-9-]*[a-z0-9]$/)
+        .describe('Zone name (2-64 chars, lowercase alphanumeric and hyphens)'),
+    },
+    async ({ name }) => {
+      const res = await api.post('/api/core/zones', { Name: name }, { auth: 'account' });
+      return { content: [{ type: 'text', text: JSON.stringify(res.data, null, 2) }] };
+    }
+  );
+
+  server.tool(
+    'zone_delete',
+    'Delete an entire zone and all its files. This is DESTRUCTIVE and cannot be undone. Initiates edge cache purge.',
+    { zone_id: z.string().describe('Zone identifier to delete') },
+    async ({ zone_id }) => {
+      const res = await api.del(`/api/core/zones/${zone_id}`, { auth: 'account' });
+      return { content: [{ type: 'text', text: JSON.stringify(res.data, null, 2) }] };
+    }
+  );
+
+  server.tool(
+    'domain_add',
+    'Add a custom domain to a zone. SSL/TLS certificate is provisioned automatically. Create a CNAME record pointing to cloudcdn-pro.pages.dev.',
+    {
+      zone_id: z.string().describe('Zone to attach the domain to'),
+      hostname: z.string().describe('Fully qualified domain (e.g., "cdn.example.com")'),
+    },
+    async ({ zone_id, hostname }) => {
+      const res = await api.post(`/api/core/zones/${zone_id}/domains`, { Hostname: hostname }, { auth: 'account' });
+      return { content: [{ type: 'text', text: JSON.stringify(res.data, null, 2) }] };
+    }
+  );
+
+  server.tool(
+    'rules_get',
+    'Read the current Cloudflare Pages edge configuration files (_headers and _redirects).',
+    {},
+    async () => {
+      const res = await api.get('/api/core/rules', { auth: 'account' });
+      return { content: [{ type: 'text', text: JSON.stringify(res.data, null, 2) }] };
+    }
+  );
+
+  server.tool(
+    'rules_update',
+    'Update the _headers or _redirects edge configuration file. Committed via Git, deployed in ~60-90 seconds.',
+    {
+      file: z.enum(['_headers', '_redirects']).describe('Which edge config file to update'),
+      content: z.string().max(100000).describe('Full file content'),
+    },
+    async ({ file, content }) => {
+      const res = await api.post('/api/core/rules', { File: file, Content: content }, { auth: 'account' });
+      return { content: [{ type: 'text', text: JSON.stringify(res.data, null, 2) }] };
+    }
+  );
+}

package/lib/tools/delivery.js

@@ -0,0 +1,127 @@
+/**
+ * Edge-delivery MCP tools — transforms, cache purge, signed URLs, HLS
+ * playlists, and the asset pipeline.
+ *
+ * Auth is per-tool: `transform_image` and `stream_playlist` are public,
+ * `cache_purge` uses PurgeKey, `signed_url_generate` and `pipeline_ingest`
+ * use AccountKey.
+ *
+ * @module @sebastienrousseau/cloudcdn-mcp/lib/tools/delivery
+ */
+
+import { z } from 'zod';
+import * as api from '../api-client.js';
+
+/**
+ * Register the delivery tools (`transform_image`, `cache_purge`,
+ * `signed_url_generate`, `stream_playlist`, `pipeline_ingest`) on the
+ * given MCP server.
+ *
+ * @param {{ tool: Function }} server - The MCP server instance.
+ * @returns {void}
+ */
+export function registerDeliveryTools(server) {
+  server.tool(
+    'transform_image',
+    'Generate a transformed image URL with resize, format conversion, blur, and sharpen. Returns the CDN URL (does not download the image). Rate limited to 50,000/month.',
+    {
+      url: z.string().describe('Relative asset path (e.g., "/akande/v1/logos/akande.svg")'),
+      w: z.number().int().min(1).max(8192).optional().describe('Width in pixels'),
+      h: z.number().int().min(1).max(8192).optional().describe('Height in pixels'),
+      fit: z.enum(['cover', 'contain', 'fill', 'inside', 'outside']).optional(),
+      format: z.enum(['auto', 'webp', 'avif', 'png', 'jpeg']).optional(),
+      q: z.number().int().min(1).max(100).optional().describe('Quality (1-100)'),
+      blur: z.number().int().min(1).max(250).optional(),
+      sharpen: z.number().int().min(1).max(10).optional(),
+      gravity: z.enum([
+        'center', 'north', 'south', 'east', 'west',
+        'northeast', 'northwest', 'southeast', 'southwest',
+        'face', 'auto',
+      ]).optional(),
+    },
+    async (params) => {
+      // Build the transform URL for the agent to use/reference
+      const queryParams = {};
+      for (const [k, v] of Object.entries(params)) {
+        if (v !== undefined) queryParams[k] = v;
+      }
+      const transformUrl = new URL('/api/transform', api.BASE_URL);
+      for (const [k, v] of Object.entries(queryParams)) {
+        transformUrl.searchParams.set(k, String(v));
+      }
+
+      // Also verify it works by making the request
+      const res = await api.get('/api/transform', { params: queryParams });
+      const result = {
+        transform_url: transformUrl.toString(),
+        status: res.status,
+        ok: res.ok,
+        content_type: res.data?.contentType || null,
+      };
+      return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+    }
+  );
+
+  server.tool(
+    'cache_purge',
+    'Purge the Cloudflare CDN cache by specific URLs, surrogate tags, or purge everything. Rate limited to 100/day. Exactly one of urls, tags, or purge_everything must be provided.',
+    {
+      urls: z.array(z.string()).max(30).optional().describe('Array of full URLs to purge (must start with https://cloudcdn.pro/)'),
+      tags: z.array(z.string()).max(30).optional().describe('Array of cache tags to purge (alphanumeric with hyphens)'),
+      purge_everything: z.boolean().optional().describe('Set true to purge ALL cached content'),
+    },
+    async ({ urls, tags, purge_everything }) => {
+      const body = {};
+      if (purge_everything) body.purge_everything = true;
+      else if (urls) body.urls = urls;
+      else if (tags) body.tags = tags;
+
+      const res = await api.post('/api/purge', body, { auth: 'purge' });
+      return { content: [{ type: 'text', text: JSON.stringify(res.data, null, 2) }] };
+    }
+  );
+
+  server.tool(
+    'signed_url_generate',
+    'Mint a time-limited HMAC-signed URL for a protected asset. Returns `{ url, expiresAt }` where `url` is ready to share; the signature is verified at the edge with constant-time HMAC-SHA256. Use for paywalled downloads, expiring sharable links, or any asset you want gated without baking auth into every request.',
+    {
+      path:        z.string().min(1).max(1024).describe('Relative asset path (e.g. "/clients/acme/private/report.pdf")'),
+      expires_in:  z.number().int().min(60).max(60 * 60 * 24 * 30).default(3600).optional()
+                     .describe('TTL in seconds. Default 3600 (1 hour); max 30 days.'),
+    },
+    async ({ path, expires_in = 3600 }) => {
+      const expires = Math.floor(Date.now() / 1000) + expires_in;
+      const res = await api.post('/api/signed', { path, expires }, { auth: 'account' });
+      return { content: [{ type: 'text', text: JSON.stringify(res.data, null, 2) }] };
+    }
+  );
+
+  server.tool(
+    'stream_playlist',
+    'Build the HLS playlist URL for an adaptive-bitrate video. Returns `{ playlist_url }` ready for an HLS-compatible player. The edge serves an `.m3u8` index plus byte-range segments; bandwidth-adaptive selection happens client-side.',
+    {
+      asset_id: z.string().min(1).describe('Video asset ID or relative path (e.g. "/stocks/promo/launch.mp4")'),
+    },
+    async ({ asset_id }) => {
+      const res = await api.get('/api/stream', { params: { id: asset_id } });
+      return { content: [{ type: 'text', text: JSON.stringify(res.data, null, 2) }] };
+    }
+  );
+
+  server.tool(
+    'pipeline_ingest',
+    'Scaffold a full zone from a single SVG upload. Creates logos, icons, favicon, and directory structure in a single atomic commit.',
+    {
+      mode: z.enum(['client', 'stock']).describe('"client" creates a full zone scaffold, "stock" uploads to shared library'),
+      name: z.string().optional().describe('Zone name (required for client mode)'),
+      svg: z.string().describe('Base64-encoded SVG content'),
+      generateFavicon: z.boolean().default(true).optional(),
+      generateIcons: z.boolean().default(true).optional(),
+      generateBanners: z.boolean().default(true).optional(),
+    },
+    async (params) => {
+      const res = await api.post('/api/pipeline', params, { auth: 'account' });
+      return { content: [{ type: 'text', text: JSON.stringify(res.data, null, 2) }] };
+    }
+  );
+}

package/lib/tools/insights.js

@@ -0,0 +1,96 @@
+/**
+ * Insights / analytics MCP tools — summary, top assets, geography, errors,
+ * per-asset roll-ups, and the long-retention audit log.
+ *
+ * The first five are AccessKey-gated (observability data); `audit_logs`
+ * is AccountKey-gated (control-plane history).
+ *
+ * @module @sebastienrousseau/cloudcdn-mcp/lib/tools/insights
+ */
+
+import { z } from 'zod';
+import * as api from '../api-client.js';
+
+const daysParam = z.number().int().min(1).max(90).default(7).optional().describe('Number of days to query (1-90)');
+
+/**
+ * Register the insights tools (`insights_*`, `audit_logs`) on the given
+ * MCP server.
+ *
+ * @param {{ tool: Function }} server - The MCP server instance.
+ * @returns {void}
+ */
+export function registerInsightsTools(server) {
+  server.tool(
+    'insights_summary',
+    'Get aggregated analytics: total requests, bandwidth, cache hit rate, and unique countries over a time window.',
+    {
+      days: daysParam,
+      zone: z.string().optional().describe('Optional zone filter'),
+    },
+    async (params) => {
+      const res = await api.get('/api/insights/summary', { auth: 'access', params });
+      return { content: [{ type: 'text', text: JSON.stringify(res.data, null, 2) }] };
+    }
+  );
+
+  server.tool(
+    'insights_top_assets',
+    'Get the most requested assets ranked by hit count.',
+    {
+      days: daysParam,
+      limit: z.number().int().min(1).max(100).default(20).optional().describe('Number of top assets to return'),
+    },
+    async (params) => {
+      const res = await api.get('/api/insights/top-assets', { auth: 'access', params });
+      return { content: [{ type: 'text', text: JSON.stringify(res.data, null, 2) }] };
+    }
+  );
+
+  server.tool(
+    'insights_geography',
+    'Get request distribution by country code.',
+    { days: daysParam },
+    async (params) => {
+      const res = await api.get('/api/insights/geography', { auth: 'access', params });
+      return { content: [{ type: 'text', text: JSON.stringify(res.data, null, 2) }] };
+    }
+  );
+
+  server.tool(
+    'insights_errors',
+    'Get error tracking data: breakdown by HTTP status code with the most affected paths.',
+    { days: daysParam },
+    async (params) => {
+      const res = await api.get('/api/insights/errors', { auth: 'access', params });
+      return { content: [{ type: 'text', text: JSON.stringify(res.data, null, 2) }] };
+    }
+  );
+
+  server.tool(
+    'insights_asset',
+    'Get per-asset analytics for a single path: request count, daily breakdown, and error roll-up by HTTP status. Path matching is tolerant of leading-slash differences.',
+    {
+      path: z.string().min(1).max(2048).describe('Asset path to query (e.g. "clients/akande/v1/logos/logo.svg" — leading slash optional)'),
+      days: daysParam,
+    },
+    async (params) => {
+      const res = await api.get('/api/insights/asset', { auth: 'access', params });
+      return { content: [{ type: 'text', text: JSON.stringify(res.data, null, 2) }] };
+    }
+  );
+
+  server.tool(
+    'audit_logs',
+    'Read the persistent control-plane audit trail: token creates/revokes, webhook registers/deletes, zone creates, successful purges. Records carry timestamp, action, client IP, user agent, request trace ID, and action-specific metadata. AccountKey-gated.',
+    {
+      days: z.number().int().min(1).max(90).default(7).optional().describe('Days to look back (1-90)'),
+      action: z.string().optional().describe('Filter to a single action (e.g. "token.create", "webhook.delete", "zone.create", "purge.execute")'),
+      limit: z.number().int().min(1).max(5000).default(500).optional().describe('Max entries to return (1-5000)'),
+    },
+    async (params) => {
+      const res = await api.get('/api/core/audit-logs', { auth: 'account', params });
+      return { content: [{ type: 'text', text: JSON.stringify(res.data, null, 2) }] };
+    }
+  );
+}

package/lib/tools/logs.js

@@ -0,0 +1,34 @@
+/**
+ * Operations / log-query MCP tools.
+ *
+ * @module @sebastienrousseau/cloudcdn-mcp/lib/tools/logs
+ */
+
+import { z } from 'zod';
+import * as api from '../api-client.js';
+
+/**
+ * Register the log tools (`logs_query`) on the given MCP server.
+ *
+ * @param {{ tool: Function }} server - The MCP server instance.
+ * @returns {void}
+ */
+export function registerLogTools(server) {
+  server.tool(
+    'logs_query',
+    'Query historical log entries with optional level filter. Returns structured JSON logs.',
+    {
+      days: z.number().int().min(1).max(7).default(1).optional().describe('Number of days to query'),
+      level: z.enum(['info', 'warn', 'error']).optional().describe('Filter by log level'),
+      limit: z.number().int().min(1).max(500).default(100).optional(),
+    },
+    async ({ days, level, limit }) => {
+      const params = {};
+      if (days) params.days = days;
+      if (level) params.level = level;
+      if (limit) params.limit = limit;
+      const res = await api.get('/api/logs', { auth: 'account', params });
+      return { content: [{ type: 'text', text: JSON.stringify(res.data, null, 2) }] };
+    }
+  );
+}

package/lib/tools/storage.js

@@ -0,0 +1,71 @@
+/**
+ * Storage-plane MCP tools — read/write the Bunny.net-compatible object store
+ * that backs CloudCDN. AccessKey auth on every call.
+ *
+ * @module @sebastienrousseau/cloudcdn-mcp/lib/tools/storage
+ */
+
+import { z } from 'zod';
+import * as api from '../api-client.js';
+
+/**
+ * Register the storage tools (`storage_list`, `storage_upload`,
+ * `storage_delete`, `storage_batch_upload`) on the given MCP server.
+ *
+ * @param {{ tool: Function }} server - The MCP server instance.
+ * @returns {void}
+ */
+export function registerStorageTools(server) {
+  server.tool(
+    'storage_list',
+    'List files and subdirectories at a storage path. Returns Bunny.net-compatible file entries with names, sizes, and timestamps.',
+    { path: z.string().describe('Directory path to list (e.g., "clients/akande/v1/logos/")') },
+    async ({ path }) => {
+      const res = await api.get(`/api/storage/${path}`, { auth: 'access' });
+      return { content: [{ type: 'text', text: JSON.stringify(res.data, null, 2) }] };
+    }
+  );
+
+  server.tool(
+    'storage_upload',
+    'Upload a file to the CDN. The file is committed via Git and deployed to 300+ edge locations in ~60-90 seconds.',
+    {
+      path: z.string().describe('Destination path (e.g., "clients/akande/v1/logos/logo.svg")'),
+      content_base64: z.string().describe('File content encoded as base64'),
+      checksum: z.string().optional().describe('Optional SHA-256 hex checksum for integrity verification'),
+    },
+    async ({ path, content_base64, checksum }) => {
+      const body = Uint8Array.from(atob(content_base64), c => c.charCodeAt(0));
+      const headers = {};
+      if (checksum) headers.Checksum = checksum;
+      const res = await api.put(`/api/storage/${path}`, body, { auth: 'access', headers });
+      return { content: [{ type: 'text', text: JSON.stringify(res.data, null, 2) }] };
+    }
+  );
+
+  server.tool(
+    'storage_delete',
+    'Delete a file from the CDN. Removes it from the repository and initiates an edge cache purge.',
+    { path: z.string().describe('File path to delete (e.g., "clients/akande/v1/logos/old.svg")') },
+    async ({ path }) => {
+      const res = await api.del(`/api/storage/${path}`, { auth: 'access' });
+      return { content: [{ type: 'text', text: JSON.stringify(res.data, null, 2) }] };
+    }
+  );
+
+  server.tool(
+    'storage_batch_upload',
+    'Upload up to 50 files in a single atomic Git commit. More efficient than individual uploads for multiple assets.',
+    {
+      files: z.array(z.object({
+        path: z.string().describe('Destination path for this file'),
+        content: z.string().describe('Base64-encoded file content'),
+        encoding: z.enum(['base64']).default('base64'),
+      })).max(50).describe('Array of file objects to upload'),
+    },
+    async ({ files }) => {
+      const res = await api.post('/api/storage/batch', { files }, { auth: 'access' });
+      return { content: [{ type: 'text', text: JSON.stringify(res.data, null, 2) }] };
+    }
+  );
+}

package/lib/tools/tokens.js

@@ -0,0 +1,57 @@
+/**
+ * Scoped-API-token MCP tools — list, create, and revoke tokens. Secrets
+ * are SHA-256 hashed at rest and returned to the caller exactly once at
+ * creation time. AccountKey auth on every call.
+ *
+ * @module @sebastienrousseau/cloudcdn-mcp/lib/tools/tokens
+ */
+
+import { z } from 'zod';
+import * as api from '../api-client.js';
+
+/**
+ * Register the token tools (`token_list`, `token_create`, `token_revoke`)
+ * on the given MCP server.
+ *
+ * @param {{ tool: Function }} server - The MCP server instance.
+ * @returns {void}
+ */
+export function registerTokenTools(server) {
+  server.tool(
+    'token_list',
+    'List all API tokens (secrets redacted, only prefix shown).',
+    {},
+    async () => {
+      const res = await api.get('/api/tokens', { auth: 'account' });
+      return { content: [{ type: 'text', text: JSON.stringify(res.data, null, 2) }] };
+    }
+  );
+
+  server.tool(
+    'token_create',
+    'Create a new scoped API token. The secret is returned ONCE and cannot be retrieved again.',
+    {
+      name: z.string().max(100).describe('Human-readable token name (e.g., "CI deploy bot")'),
+      scopes: z.array(z.enum([
+        'storage:read', 'storage:write', 'assets:read', 'insights:read',
+        'zones:read', 'zones:write', 'purge:write', 'pipeline:write',
+        'webhooks:read', 'webhooks:write',
+      ])).describe('Permission scopes for this token'),
+      expiresInDays: z.number().int().min(1).max(365).default(90).optional().describe('Token lifetime in days'),
+    },
+    async ({ name, scopes, expiresInDays }) => {
+      const res = await api.post('/api/tokens', { name, scopes, expiresInDays }, { auth: 'account' });
+      return { content: [{ type: 'text', text: JSON.stringify(res.data, null, 2) }] };
+    }
+  );
+
+  server.tool(
+    'token_revoke',
+    'Revoke an API token by its ID. The token will immediately stop working.',
+    { id: z.string().describe('Token ID to revoke') },
+    async ({ id }) => {
+      const res = await api.del('/api/tokens', { auth: 'account', params: { id } });
+      return { content: [{ type: 'text', text: JSON.stringify(res.data, null, 2) }] };
+    }
+  );
+}

package/lib/tools/webhooks.js

@@ -0,0 +1,59 @@
+/**
+ * Webhook MCP tools — list, create, and delete webhook subscriptions.
+ * Deliveries are HMAC-SHA256 signed; the consumer Worker takes care of
+ * the retry + DLQ flow. AccountKey auth on every call.
+ *
+ * @module @sebastienrousseau/cloudcdn-mcp/lib/tools/webhooks
+ */
+
+import { z } from 'zod';
+import * as api from '../api-client.js';
+
+/**
+ * Register the webhook tools (`webhook_list`, `webhook_create`,
+ * `webhook_delete`) on the given MCP server.
+ *
+ * @param {{ tool: Function }} server - The MCP server instance.
+ * @returns {void}
+ */
+export function registerWebhookTools(server) {
+  server.tool(
+    'webhook_list',
+    'List all registered webhooks.',
+    {},
+    async () => {
+      const res = await api.get('/api/webhooks', { auth: 'account' });
+      return { content: [{ type: 'text', text: JSON.stringify(res.data, null, 2) }] };
+    }
+  );
+
+  server.tool(
+    'webhook_create',
+    'Register a new webhook for CDN events (asset.created, asset.deleted, zone.created, etc.). Supports HMAC-SHA256 signed delivery.',
+    {
+      url: z.string().describe('Webhook delivery URL (must be https://)'),
+      events: z.array(z.enum([
+        'asset.created', 'asset.deleted', 'asset.updated',
+        'zone.created', 'zone.deleted',
+        'purge.completed', 'pipeline.completed',
+      ])).describe('Events to subscribe to'),
+      secret: z.string().optional().describe('Optional HMAC secret for signature verification'),
+    },
+    async ({ url, events, secret }) => {
+      const body = { url, events };
+      if (secret) body.secret = secret;
+      const res = await api.post('/api/webhooks', body, { auth: 'account' });
+      return { content: [{ type: 'text', text: JSON.stringify(res.data, null, 2) }] };
+    }
+  );
+
+  server.tool(
+    'webhook_delete',
+    'Remove a registered webhook by its ID.',
+    { id: z.string().describe('Webhook ID to remove') },
+    async ({ id }) => {
+      const res = await api.del('/api/webhooks', { auth: 'account', params: { id } });
+      return { content: [{ type: 'text', text: JSON.stringify(res.data, null, 2) }] };
+    }
+  );
+}

package/package.json

@@ -0,0 +1,73 @@
+{
+  "name": "@sebastienrousseau/cloudcdn-mcp",
+  "version": "0.1.1",
+  "description": "MCP server for CloudCDN \u2014 lets AI agents autonomously manage digital assets, zones, image transforms, cache, and edge analytics.",
+  "type": "module",
+  "main": "./index.js",
+  "exports": {
+    ".": "./index.js",
+    "./server": "./server.js",
+    "./api-client": "./lib/api-client.js",
+    "./package.json": "./package.json"
+  },
+  "bin": {
+    "cloudcdn-mcp": "./index.js"
+  },
+  "files": [
+    "index.js",
+    "server.js",
+    "lib/",
+    "README.md",
+    "LICENSE-APACHE",
+    "LICENSE-MIT"
+  ],
+  "scripts": {
+    "start": "node index.js",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage"
+  },
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "cloudcdn",
+    "cdn",
+    "cloudflare",
+    "ai-agents",
+    "claude",
+    "cursor",
+    "windsurf",
+    "vectorize"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.12.0",
+    "zod": "4.6.7"
+  },
+  "devDependencies": {
+    "@vitest/coverage-v8": "4.1.12",
+    "vitest": "4.1.12"
+  },
+  "overrides": {
+    "hono": ">=4.13.11 <5.0.0",
+    "@hono/node-server": "^1.19.15",
+    "ip-address": ">=10.7.4 <11.0.0",
+    "vite": ">=8.1.6 <9.0.0",
+    "fast-uri": "3.1.8",
+    "nanoid": "^5.1.7",
+    "qs": "^6.16.0"
+  },
+  "homepage": "https://cloudcdn.pro",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/sebastienrousseau/cloudcdn.pro.git",
+    "directory": "mcp"
+  },
+  "bugs": {
+    "url": "https://github.com/sebastienrousseau/cloudcdn.pro/issues"
+  },
+  "author": "Sebastien Rousseau",
+  "license": "Apache-2.0 OR MIT"
+}