@curenorway/kode-mcp 1.0.0

package/README.md

@@ -0,0 +1,152 @@
+# Cure Kode MCP Server
+
+MCP (Model Context Protocol) server that enables AI agents to manage Webflow scripts via Cure Kode CDN.
+
+## What is this?
+
+This MCP server allows AI assistants like Claude to directly interact with Cure Kode:
+- List, create, update, and delete scripts
+- Deploy to staging and production
+- Check deployment status
+- Analyze web pages for script detection
+
+## Installation
+
+### For Claude Code
+
+Add to your Claude Code configuration (`~/.claude/claude_code_config.json`):
+
+```json
+{
+  "mcpServers": {
+    "cure-kode": {
+      "command": "npx",
+      "args": ["@curenorway/kode-mcp"]
+    }
+  }
+}
+```
+
+### For Cursor / Other IDEs
+
+Refer to your IDE's MCP configuration documentation.
+
+## Configuration
+
+The MCP server needs to know which site to manage. Configure via:
+
+### Option 1: Project Config (Recommended)
+
+Run `kode init` in your project to create `.cure-kode/config.json`:
+
+```json
+{
+  "siteId": "your-site-uuid",
+  "siteSlug": "my-site",
+  "siteName": "My Site",
+  "apiKey": "ck_...",
+  "scriptsDir": "kode",
+  "environment": "staging"
+}
+```
+
+### Option 2: Environment Variables
+
+```bash
+export CURE_KODE_API_KEY="ck_..."
+export CURE_KODE_SITE_ID="your-site-uuid"
+export CURE_KODE_API_URL="https://cure-app-v2-production.up.railway.app"  # optional
+```
+
+## Available Tools
+
+| Tool | Description |
+|------|-------------|
+| `kode_list_scripts` | List all scripts for the site |
+| `kode_get_script` | Get script content by slug |
+| `kode_create_script` | Create a new script |
+| `kode_update_script` | Update script content |
+| `kode_delete_script` | Delete a script |
+| `kode_deploy` | Deploy to staging/production |
+| `kode_promote` | Promote staging to production |
+| `kode_status` | Get deployment status |
+| `kode_fetch_html` | Analyze a webpage |
+| `kode_list_pages` | List page definitions |
+| `kode_site_info` | Get site info and CDN URL |
+
+## Example Prompts
+
+Once configured, you can ask Claude:
+
+```
+"List all the scripts in Cure Kode"
+"Create a new tracking script that logs page views"
+"Update the init.js script to add error handling"
+"Deploy to staging"
+"What's the current deployment status?"
+"Analyze example.com to see what scripts are loaded"
+```
+
+## How It Works
+
+```
+┌─────────────────┐      ┌─────────────────┐      ┌─────────────────┐
+│   AI Agent      │ MCP  │  Kode MCP       │ REST │  Cure Kode API  │
+│  (Claude/etc)   │─────▶│  Server         │─────▶│  (Railway)      │
+└─────────────────┘      └─────────────────┘      └─────────────────┘
+                                │
+                                ▼
+                         ┌─────────────────┐
+                         │ Local Scripts   │
+                         │ (.cure-kode/)   │
+                         └─────────────────┘
+```
+
+1. AI agent calls MCP tools (e.g., `kode_create_script`)
+2. MCP server reads config from `.cure-kode/config.json`
+3. MCP server calls Cure Kode REST API with API key
+4. Results returned to AI agent
+
+## Security
+
+- API keys are stored locally in `.cure-kode/config.json` (git-ignored)
+- Keys are scoped per-site with specific permissions
+- All API calls are authenticated
+- Never commit API keys to version control
+
+## Troubleshooting
+
+### "Cure Kode not configured"
+
+Either:
+1. Run `kode init` in your project directory
+2. Set `CURE_KODE_API_KEY` and `CURE_KODE_SITE_ID` environment variables
+
+### "API key invalid"
+
+- Check your API key starts with `ck_`
+- Verify the key hasn't expired
+- Ensure the key has required permissions
+
+### Tools not appearing in Claude
+
+- Restart Claude Code after configuration changes
+- Check the MCP server is running: `npx @curenorway/kode-mcp`
+- Verify config file syntax
+
+## Development
+
+```bash
+# Install dependencies
+pnpm install
+
+# Build
+pnpm build
+
+# Run locally
+node dist/index.js
+```
+
+## License
+
+MIT

package/dist/index.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/index.js

@@ -0,0 +1,730 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema,
+  ListResourcesRequestSchema,
+  ReadResourceRequestSchema
+} from "@modelcontextprotocol/sdk/types.js";
+
+// src/api.ts
+var KodeApiClient = class {
+  apiUrl;
+  apiKey;
+  constructor(apiUrl, apiKey) {
+    this.apiUrl = apiUrl.replace(/\/$/, "");
+    this.apiKey = apiKey;
+  }
+  async request(path3, options = {}) {
+    const url = `${this.apiUrl}${path3}`;
+    const headers = {
+      "Content-Type": "application/json",
+      "X-API-Key": this.apiKey,
+      ...options.headers
+    };
+    const response = await fetch(url, {
+      ...options,
+      headers
+    });
+    if (!response.ok) {
+      const error = await response.json().catch(() => ({ error: response.statusText }));
+      throw new Error(error.error || `HTTP ${response.status}: ${response.statusText}`);
+    }
+    return response.json();
+  }
+  // Site operations
+  async getSite(siteId) {
+    return this.request(`/api/cdn/sites/${siteId}`);
+  }
+  async listSites() {
+    return this.request("/api/cdn/sites");
+  }
+  // Script operations
+  async listScripts(siteId) {
+    return this.request(`/api/cdn/sites/${siteId}/scripts`);
+  }
+  async getScript(scriptId) {
+    return this.request(`/api/cdn/scripts/${scriptId}`);
+  }
+  async createScript(siteId, data) {
+    return this.request(`/api/cdn/sites/${siteId}/scripts`, {
+      method: "POST",
+      body: JSON.stringify(data)
+    });
+  }
+  async updateScript(scriptId, data) {
+    return this.request(`/api/cdn/scripts/${scriptId}`, {
+      method: "PUT",
+      body: JSON.stringify(data)
+    });
+  }
+  async deleteScript(scriptId) {
+    await this.request(`/api/cdn/scripts/${scriptId}`, {
+      method: "DELETE"
+    });
+  }
+  // Page operations
+  async listPages(siteId) {
+    return this.request(`/api/cdn/sites/${siteId}/pages`);
+  }
+  // Deployment operations
+  async deploy(siteId, options = {}) {
+    return this.request("/api/cdn/deploy", {
+      method: "POST",
+      body: JSON.stringify({
+        siteId,
+        environment: options.environment || "staging",
+        scriptIds: options.scriptIds,
+        notes: options.notes
+      })
+    });
+  }
+  async promoteToProduction(siteId, stagingDeploymentId) {
+    return this.request("/api/cdn/deploy/promote", {
+      method: "POST",
+      body: JSON.stringify({
+        siteId,
+        stagingDeploymentId
+      })
+    });
+  }
+  async getDeploymentStatus(siteId) {
+    return this.request(`/api/cdn/sites/${siteId}/deployments/status`);
+  }
+  // HTML operations
+  async fetchHtml(siteId, url) {
+    return this.request("/api/cdn/fetch-html", {
+      method: "POST",
+      body: JSON.stringify({ siteId, url })
+    });
+  }
+  // Validate API key
+  async validateKey() {
+    try {
+      await this.listSites();
+      return true;
+    } catch {
+      return false;
+    }
+  }
+};
+
+// src/config.ts
+import * as fs from "fs";
+import * as path from "path";
+var DEFAULT_API_URL = "https://cure-app-v2-production.up.railway.app";
+var CONFIG_DIR = ".cure-kode";
+var CONFIG_FILE = "config.json";
+function findProjectRoot(startDir = process.cwd()) {
+  let currentDir = startDir;
+  while (currentDir !== path.dirname(currentDir)) {
+    const configPath = path.join(currentDir, CONFIG_DIR, CONFIG_FILE);
+    if (fs.existsSync(configPath)) {
+      return currentDir;
+    }
+    currentDir = path.dirname(currentDir);
+  }
+  return void 0;
+}
+function loadProjectConfig() {
+  const projectRoot = findProjectRoot();
+  if (!projectRoot) return void 0;
+  const configPath = path.join(projectRoot, CONFIG_DIR, CONFIG_FILE);
+  if (!fs.existsSync(configPath)) return void 0;
+  try {
+    const content = fs.readFileSync(configPath, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return void 0;
+  }
+}
+function getConfig() {
+  const envApiKey = process.env.CURE_KODE_API_KEY;
+  const envApiUrl = process.env.CURE_KODE_API_URL;
+  const envSiteId = process.env.CURE_KODE_SITE_ID;
+  const projectConfig = loadProjectConfig();
+  const apiKey = envApiKey || projectConfig?.apiKey;
+  if (!apiKey) {
+    return void 0;
+  }
+  const siteId = envSiteId || projectConfig?.siteId;
+  if (!siteId) {
+    return void 0;
+  }
+  return {
+    apiKey,
+    siteId,
+    siteSlug: projectConfig?.siteSlug || "unknown",
+    siteName: projectConfig?.siteName || "Unknown Site",
+    apiUrl: envApiUrl || projectConfig?.apiUrl || DEFAULT_API_URL
+  };
+}
+function hasConfig() {
+  return getConfig() !== void 0;
+}
+function getScriptsDir() {
+  const projectRoot = findProjectRoot();
+  const projectConfig = loadProjectConfig();
+  if (!projectRoot || !projectConfig) return void 0;
+  return path.join(projectRoot, projectConfig.scriptsDir);
+}
+
+// src/index.ts
+import * as fs2 from "fs";
+import * as path2 from "path";
+var server = new Server(
+  {
+    name: "cure-kode",
+    version: "1.0.0"
+  },
+  {
+    capabilities: {
+      tools: {},
+      resources: {}
+    }
+  }
+);
+var apiClient = null;
+function getApiClient() {
+  if (!apiClient) {
+    const config = getConfig();
+    if (!config) {
+      throw new Error(
+        "Cure Kode not configured. Set CURE_KODE_API_KEY and CURE_KODE_SITE_ID environment variables, or run from a directory with .cure-kode/config.json (use `kode init` to create one)."
+      );
+    }
+    apiClient = new KodeApiClient(config.apiUrl, config.apiKey);
+  }
+  return apiClient;
+}
+function getSiteId() {
+  const config = getConfig();
+  if (!config) {
+    throw new Error("Cure Kode not configured");
+  }
+  return config.siteId;
+}
+server.setRequestHandler(ListToolsRequestSchema, async () => {
+  return {
+    tools: [
+      {
+        name: "kode_list_scripts",
+        description: "List all scripts for the current Cure Kode site. Returns script names, types (javascript/css), scopes (global/page-specific), and version numbers.",
+        inputSchema: {
+          type: "object",
+          properties: {},
+          required: []
+        }
+      },
+      {
+        name: "kode_get_script",
+        description: "Get the full content of a specific script by its slug (filename without extension) or ID.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            slug: {
+              type: "string",
+              description: 'Script slug (e.g., "init", "tracking") or script ID (UUID)'
+            }
+          },
+          required: ["slug"]
+        }
+      },
+      {
+        name: "kode_create_script",
+        description: "Create a new script on the Cure Kode CDN. The script will be available at the CDN URL after deployment.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            name: {
+              type: "string",
+              description: 'Script name/slug (lowercase, hyphens allowed, e.g., "my-script")'
+            },
+            type: {
+              type: "string",
+              enum: ["javascript", "css"],
+              description: "Script type"
+            },
+            content: {
+              type: "string",
+              description: "Script content (JavaScript or CSS code)"
+            },
+            scope: {
+              type: "string",
+              enum: ["global", "page-specific"],
+              description: 'Script scope - "global" loads on all pages, "page-specific" only on assigned pages. Default: global'
+            }
+          },
+          required: ["name", "type", "content"]
+        }
+      },
+      {
+        name: "kode_update_script",
+        description: "Update an existing script's content. This creates a new version of the script.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            slug: {
+              type: "string",
+              description: "Script slug or ID to update"
+            },
+            content: {
+              type: "string",
+              description: "New script content"
+            },
+            changeSummary: {
+              type: "string",
+              description: "Brief description of the changes (for version history)"
+            }
+          },
+          required: ["slug", "content"]
+        }
+      },
+      {
+        name: "kode_delete_script",
+        description: "Delete a script from the Cure Kode CDN. This cannot be undone.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            slug: {
+              type: "string",
+              description: "Script slug or ID to delete"
+            }
+          },
+          required: ["slug"]
+        }
+      },
+      {
+        name: "kode_deploy",
+        description: "Deploy scripts to staging or production environment. Always deploy to staging first and test before promoting to production.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            environment: {
+              type: "string",
+              enum: ["staging", "production"],
+              description: "Target environment. Default: staging"
+            },
+            notes: {
+              type: "string",
+              description: 'Deployment notes (e.g., "Added new tracking script")'
+            }
+          },
+          required: []
+        }
+      },
+      {
+        name: "kode_promote",
+        description: "Promote the latest staging deployment to production. Use this after testing on staging.",
+        inputSchema: {
+          type: "object",
+          properties: {},
+          required: []
+        }
+      },
+      {
+        name: "kode_status",
+        description: "Get the current deployment status for both staging and production environments.",
+        inputSchema: {
+          type: "object",
+          properties: {},
+          required: []
+        }
+      },
+      {
+        name: "kode_fetch_html",
+        description: "Fetch and analyze a webpage to see what scripts are loaded, detect Webflow components, and check if Cure Kode is installed.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            url: {
+              type: "string",
+              description: 'Full URL to analyze (e.g., "https://example.com")'
+            }
+          },
+          required: ["url"]
+        }
+      },
+      {
+        name: "kode_list_pages",
+        description: "List all page definitions for the site. Pages define URL patterns for page-specific scripts.",
+        inputSchema: {
+          type: "object",
+          properties: {},
+          required: []
+        }
+      },
+      {
+        name: "kode_site_info",
+        description: "Get information about the current Cure Kode site including domains and CDN URLs.",
+        inputSchema: {
+          type: "object",
+          properties: {},
+          required: []
+        }
+      }
+    ]
+  };
+});
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+  const { name, arguments: args } = request.params;
+  try {
+    const client = getApiClient();
+    const siteId = getSiteId();
+    switch (name) {
+      case "kode_list_scripts": {
+        const scripts = await client.listScripts(siteId);
+        const formatted = scripts.map((s) => ({
+          slug: s.slug,
+          name: s.name,
+          type: s.type,
+          scope: s.scope,
+          version: s.current_version,
+          active: s.is_active,
+          loadOrder: s.load_order
+        }));
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(formatted, null, 2)
+            }
+          ]
+        };
+      }
+      case "kode_get_script": {
+        const { slug } = args;
+        const scripts = await client.listScripts(siteId);
+        const script = scripts.find((s) => s.slug === slug || s.id === slug);
+        if (!script) {
+          return {
+            content: [{ type: "text", text: `Script "${slug}" not found` }],
+            isError: true
+          };
+        }
+        return {
+          content: [
+            {
+              type: "text",
+              text: `// Script: ${script.name} (${script.type})
+// Version: ${script.current_version}
+// Scope: ${script.scope}
+
+${script.content}`
+            }
+          ]
+        };
+      }
+      case "kode_create_script": {
+        const { name: scriptName, type, content, scope } = args;
+        const script = await client.createScript(siteId, {
+          name: scriptName,
+          slug: scriptName,
+          type,
+          content,
+          scope: scope || "global"
+        });
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Created script "${script.name}" (${script.type})
+Slug: ${script.slug}
+Version: ${script.current_version}
+
+Note: Run kode_deploy to make it live.`
+            }
+          ]
+        };
+      }
+      case "kode_update_script": {
+        const { slug, content, changeSummary } = args;
+        const scripts = await client.listScripts(siteId);
+        const script = scripts.find((s) => s.slug === slug || s.id === slug);
+        if (!script) {
+          return {
+            content: [{ type: "text", text: `Script "${slug}" not found` }],
+            isError: true
+          };
+        }
+        const updated = await client.updateScript(script.id, {
+          content,
+          changeSummary: changeSummary || "Updated via MCP"
+        });
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Updated script "${updated.name}"
+New version: ${updated.current_version}
+
+Note: Run kode_deploy to make changes live.`
+            }
+          ]
+        };
+      }
+      case "kode_delete_script": {
+        const { slug } = args;
+        const scripts = await client.listScripts(siteId);
+        const script = scripts.find((s) => s.slug === slug || s.id === slug);
+        if (!script) {
+          return {
+            content: [{ type: "text", text: `Script "${slug}" not found` }],
+            isError: true
+          };
+        }
+        await client.deleteScript(script.id);
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Deleted script "${script.name}"`
+            }
+          ]
+        };
+      }
+      case "kode_deploy": {
+        const { environment, notes } = args;
+        const deployment = await client.deploy(siteId, {
+          environment: environment || "staging",
+          notes: notes || "Deployed via MCP"
+        });
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Deployment ${deployment.version} to ${deployment.environment}: ${deployment.status}
+Started: ${deployment.started_at}${deployment.completed_at ? `
+Completed: ${deployment.completed_at}` : ""}`
+            }
+          ]
+        };
+      }
+      case "kode_promote": {
+        const status = await client.getDeploymentStatus(siteId);
+        if (!status.canPromote) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: "Cannot promote: No staging deployment to promote, or staging and production are already in sync."
+              }
+            ],
+            isError: true
+          };
+        }
+        const deployment = await client.promoteToProduction(siteId);
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Promoted ${deployment.version} to production
+Status: ${deployment.status}`
+            }
+          ]
+        };
+      }
+      case "kode_status": {
+        const status = await client.getDeploymentStatus(siteId);
+        const config = getConfig();
+        let text = `Site: ${config?.siteName || "Unknown"}
+
+`;
+        text += `STAGING:
+`;
+        if (status.staging.lastSuccessful) {
+          text += `  Version: ${status.staging.lastSuccessful.version}
+`;
+          text += `  Deployed: ${status.staging.lastSuccessful.completed_at}
+`;
+        } else {
+          text += `  Not deployed
+`;
+        }
+        text += `
+PRODUCTION:
+`;
+        if (status.production.lastSuccessful) {
+          text += `  Version: ${status.production.lastSuccessful.version}
+`;
+          text += `  Deployed: ${status.production.lastSuccessful.completed_at}
+`;
+        } else {
+          text += `  Not deployed
+`;
+        }
+        text += `
+Can promote staging to production: ${status.canPromote ? "Yes" : "No"}`;
+        return {
+          content: [{ type: "text", text }]
+        };
+      }
+      case "kode_fetch_html": {
+        const { url } = args;
+        const result = await client.fetchHtml(siteId, url);
+        let text = `URL: ${result.url}
+Title: ${result.title}
+
+`;
+        text += `Webflow: ${result.hasWebflow ? "Yes" : "No"}
+`;
+        text += `Cure Kode: ${result.hasCureKode ? `Yes (${result.cureKodeVersion || "version unknown"})` : "No"}
+
+`;
+        if (result.scripts.length > 0) {
+          text += `Scripts (${result.scripts.length}):
+`;
+          for (const script of result.scripts) {
+            text += `  [${script.type}] ${script.src || "(inline)"} - ${script.position}
+`;
+          }
+        }
+        if (result.stylesheets.length > 0) {
+          text += `
+Stylesheets (${result.stylesheets.length}):
+`;
+          for (const style of result.stylesheets) {
+            text += `  [${style.type}] ${style.href || "(inline)"}
+`;
+          }
+        }
+        if (result.webflowComponents.length > 0) {
+          text += `
+Webflow Components:
+`;
+          for (const comp of result.webflowComponents) {
+            text += `  - ${comp}
+`;
+          }
+        }
+        return {
+          content: [{ type: "text", text }]
+        };
+      }
+      case "kode_list_pages": {
+        const pages = await client.listPages(siteId);
+        if (pages.length === 0) {
+          return {
+            content: [{ type: "text", text: 'No pages defined. All scripts with scope "global" will load on all pages.' }]
+          };
+        }
+        const formatted = pages.map((p) => ({
+          name: p.name,
+          slug: p.slug,
+          patterns: p.url_patterns,
+          patternType: p.pattern_type,
+          priority: p.priority
+        }));
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(formatted, null, 2)
+            }
+          ]
+        };
+      }
+      case "kode_site_info": {
+        const config = getConfig();
+        if (!config) {
+          return {
+            content: [{ type: "text", text: "Cure Kode not configured" }],
+            isError: true
+          };
+        }
+        const site = await client.getSite(siteId);
+        let text = `Site: ${site.name}
+`;
+        text += `Slug: ${site.slug}
+`;
+        text += `ID: ${site.id}
+
+`;
+        if (site.staging_domain) {
+          text += `Staging Domain: ${site.staging_domain}
+`;
+        }
+        if (site.production_domain) {
+          text += `Production Domain: ${site.production_domain}
+`;
+        }
+        if (site.domain) {
+          text += `Domain: ${site.domain}
+`;
+        }
+        text += `
+CDN URL: ${config.apiUrl}/api/cdn/${site.slug}/init.js
+`;
+        text += `
+Embed code:
+<script src="${config.apiUrl}/api/cdn/${site.slug}/init.js"></script>`;
+        return {
+          content: [{ type: "text", text }]
+        };
+      }
+      default:
+        return {
+          content: [{ type: "text", text: `Unknown tool: ${name}` }],
+          isError: true
+        };
+    }
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Error: ${error instanceof Error ? error.message : "Unknown error"}`
+        }
+      ],
+      isError: true
+    };
+  }
+});
+server.setRequestHandler(ListResourcesRequestSchema, async () => {
+  const scriptsDir = getScriptsDir();
+  if (!scriptsDir || !fs2.existsSync(scriptsDir)) {
+    return { resources: [] };
+  }
+  const files = fs2.readdirSync(scriptsDir);
+  const resources = files.filter((f) => f.endsWith(".js") || f.endsWith(".css")).map((f) => ({
+    uri: `file://${path2.join(scriptsDir, f)}`,
+    name: f,
+    mimeType: f.endsWith(".js") ? "application/javascript" : "text/css"
+  }));
+  return { resources };
+});
+server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
+  const { uri } = request.params;
+  if (!uri.startsWith("file://")) {
+    throw new Error("Invalid resource URI");
+  }
+  const filePath = uri.replace("file://", "");
+  if (!fs2.existsSync(filePath)) {
+    throw new Error("File not found");
+  }
+  const content = fs2.readFileSync(filePath, "utf-8");
+  const mimeType = filePath.endsWith(".js") ? "application/javascript" : "text/css";
+  return {
+    contents: [
+      {
+        uri,
+        mimeType,
+        text: content
+      }
+    ]
+  };
+});
+async function main() {
+  if (!hasConfig()) {
+    console.error(
+      "Warning: Cure Kode not configured. Set CURE_KODE_API_KEY and CURE_KODE_SITE_ID, or run from a directory with .cure-kode/config.json"
+    );
+  }
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  console.error("Cure Kode MCP server started");
+}
+main().catch(console.error);

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "@curenorway/kode-mcp",
+  "version": "1.0.0",
+  "description": "MCP server for Cure Kode - enables AI agents to manage Webflow scripts",
+  "type": "module",
+  "bin": {
+    "cure-kode-mcp": "./dist/index.js"
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsup src/index.ts --format esm --dts --clean",
+    "dev": "tsup src/index.ts --format esm --dts --watch",
+    "typecheck": "tsc --noEmit",
+    "prepublishOnly": "pnpm build"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.10.0",
+    "tsup": "^8.0.1",
+    "typescript": "^5.3.2"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "keywords": [
+    "cure",
+    "kode",
+    "mcp",
+    "ai",
+    "claude",
+    "webflow"
+  ],
+  "author": "Cure Norway",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/curenorway/cure-app-v2",
+    "directory": "packages/kode-mcp"
+  }
+}