@curenorway/kode-mcp 1.7.0 → 2.0.0

package/dist/index.js

@@ -10,6 +10,387 @@ import {
   ReadResourceRequestSchema
 } from "@modelcontextprotocol/sdk/types.js";
 
+// src/file-utils.ts
+import * as fs from "fs";
+import * as path from "path";
+var SUPPORTED_EXTENSIONS = [".js", ".css", ".ts", ".tsx", ".jsx"];
+var BUNDLEABLE_EXTENSIONS = [".ts", ".tsx", ".jsx"];
+var SKIP_DIRS = ["packages", "node_modules", ".git", "dist", "build"];
+function isSupportedFile(fileName) {
+  return SUPPORTED_EXTENSIONS.some((ext) => fileName.endsWith(ext));
+}
+function needsBundling(fileName) {
+  return BUNDLEABLE_EXTENSIONS.some((ext) => fileName.endsWith(ext));
+}
+function slugFromFileName(fileName) {
+  return fileName.replace(/\.(js|ts|tsx|jsx|css)$/, "");
+}
+function extFromFileName(fileName) {
+  const ext = path.extname(fileName);
+  return ext.startsWith(".") ? ext.slice(1) : ext;
+}
+function mimeTypeFromFileName(fileName) {
+  if (fileName.endsWith(".css")) return "text/css";
+  if (fileName.endsWith(".ts")) return "application/typescript";
+  if (fileName.endsWith(".tsx")) return "text/tsx";
+  if (fileName.endsWith(".jsx")) return "text/jsx";
+  return "application/javascript";
+}
+function buildFileInfo(filePath, scriptsDir, isModule) {
+  const fileName = path.basename(filePath);
+  return {
+    fileName,
+    slug: slugFromFileName(fileName),
+    ext: extFromFileName(fileName),
+    filePath,
+    needsBundling: needsBundling(fileName),
+    isModule,
+    relativePath: path.relative(scriptsDir, filePath)
+  };
+}
+function getEntryFiles(scriptsDir) {
+  if (!fs.existsSync(scriptsDir)) return [];
+  return fs.readdirSync(scriptsDir).filter((f) => {
+    const fullPath = path.join(scriptsDir, f);
+    return fs.statSync(fullPath).isFile() && isSupportedFile(f);
+  }).map((f) => buildFileInfo(path.join(scriptsDir, f), scriptsDir, false));
+}
+function getModuleFiles(scriptsDir) {
+  if (!fs.existsSync(scriptsDir)) return [];
+  const modules = [];
+  function scanDir(dir) {
+    const entries2 = fs.readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries2) {
+      const fullPath = path.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        if (!SKIP_DIRS.includes(entry.name)) {
+          scanDir(fullPath);
+        }
+      } else if (entry.isFile() && isSupportedFile(entry.name)) {
+        modules.push(buildFileInfo(fullPath, scriptsDir, true));
+      }
+    }
+  }
+  const entries = fs.readdirSync(scriptsDir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (entry.isDirectory() && !SKIP_DIRS.includes(entry.name)) {
+      scanDir(path.join(scriptsDir, entry.name));
+    }
+  }
+  return modules;
+}
+
+// src/bundler.ts
+import * as esbuild from "esbuild";
+import * as fs2 from "fs";
+import * as path2 from "path";
+async function bundleEntryPoint(options) {
+  const {
+    entryPoint,
+    scriptsDir,
+    minify = true,
+    packageAliases = {}
+  } = options;
+  try {
+    const result = await esbuild.build({
+      entryPoints: [entryPoint],
+      bundle: true,
+      format: "iife",
+      platform: "browser",
+      target: ["es2020"],
+      minify,
+      write: false,
+      // React is loaded from CDN at runtime, not bundled
+      external: ["react", "react-dom", "react/jsx-runtime", "react/jsx-dev-runtime"],
+      // Modern JSX transform — no need for React import in every file
+      jsx: "automatic",
+      jsxImportSource: "react",
+      // Resolve imports relative to scripts directory
+      absWorkingDir: scriptsDir,
+      // File type loaders
+      loader: {
+        ".ts": "ts",
+        ".tsx": "tsx",
+        ".jsx": "jsx",
+        ".js": "js",
+        ".css": "css"
+      },
+      // Try these extensions when resolving imports without extension
+      resolveExtensions: [".tsx", ".ts", ".jsx", ".js", ".css"],
+      // Package aliases for @kode/* imports (populated in Step 5)
+      alias: packageAliases,
+      // Shim require() for external React in browser IIFE context
+      // Maps require("react") → window.React, require("react-dom") → window.ReactDOM, etc.
+      banner: {
+        js: `var require=function(m){var g={"react":window.React,"react-dom":window.ReactDOM,"react-dom/client":window.ReactDOM,"react/jsx-runtime":window.React,"react/jsx-dev-runtime":window.React};if(g[m])return g[m];throw new Error("Cannot find module '"+m+"'")};`
+      },
+      // Readable output names for debugging
+      logLevel: "silent"
+    });
+    const code = result.outputFiles?.[0]?.text || "";
+    const warnings = result.warnings.map((w) => formatMessage(w));
+    const sourceCode = fs2.readFileSync(entryPoint, "utf-8");
+    return {
+      code,
+      warnings,
+      errors: [],
+      usesReact: detectReactUsage(sourceCode),
+      size: code.length
+    };
+  } catch (err) {
+    if (err && typeof err === "object" && "errors" in err) {
+      const buildErr = err;
+      return {
+        code: "",
+        warnings: buildErr.warnings.map((w) => formatMessage(w)),
+        errors: buildErr.errors.map((e) => formatMessage(e)),
+        usesReact: false,
+        size: 0
+      };
+    }
+    return {
+      code: "",
+      warnings: [],
+      errors: [err instanceof Error ? err.message : String(err)],
+      usesReact: false,
+      size: 0
+    };
+  }
+}
+function detectReactUsage(sourceCode) {
+  return /from\s+['"]react['"]/.test(sourceCode) || /from\s+['"]react-dom/.test(sourceCode) || /import\s+React/.test(sourceCode) || /require\s*\(\s*['"]react/.test(sourceCode) || /React\.createElement/.test(sourceCode);
+}
+function formatMessage(msg) {
+  let text = msg.text;
+  if (msg.location) {
+    const loc = msg.location;
+    text = `${loc.file}:${loc.line}:${loc.column}: ${text}`;
+  }
+  return text;
+}
+function getPackageAliases(scriptsDir) {
+  const pkgDir = path2.join(scriptsDir, "packages", "@kode");
+  if (!fs2.existsSync(pkgDir)) return {};
+  const aliases = {};
+  const ENTRY_FILES = ["index.ts", "index.tsx", "index.jsx", "index.js"];
+  for (const name of fs2.readdirSync(pkgDir)) {
+    const pkgPath = path2.join(pkgDir, name);
+    if (!fs2.statSync(pkgPath).isDirectory()) continue;
+    for (const entry of ENTRY_FILES) {
+      const entryPath = path2.join(pkgPath, entry);
+      if (fs2.existsSync(entryPath)) {
+        aliases[`@kode/${name}`] = entryPath;
+        break;
+      }
+    }
+  }
+  return aliases;
+}
+
+// src/pkg.ts
+import * as fs3 from "fs";
+import * as path3 from "path";
+var PACKAGES_DIR = "packages/@kode";
+function getPackagesDir(scriptsDir) {
+  return path3.join(scriptsDir, PACKAGES_DIR);
+}
+function listInstalledPackages(scriptsDir) {
+  const pkgDir = getPackagesDir(scriptsDir);
+  if (!fs3.existsSync(pkgDir)) return [];
+  return fs3.readdirSync(pkgDir).filter((name) => {
+    return fs3.statSync(path3.join(pkgDir, name)).isDirectory();
+  });
+}
+function isPackageInstalled(scriptsDir, slug) {
+  return fs3.existsSync(path3.join(getPackagesDir(scriptsDir), slug));
+}
+async function pkgAdd(client, scriptsDir, packageSlug) {
+  let pkg;
+  try {
+    pkg = await client.getPackage(packageSlug);
+  } catch {
+    return { success: false, message: `Package "${packageSlug}" not found in registry.` };
+  }
+  if (!pkg.files || pkg.files.length === 0) {
+    return { success: false, message: `Package "${packageSlug}" has no files.` };
+  }
+  const pkgDir = path3.join(getPackagesDir(scriptsDir), pkg.slug);
+  fs3.mkdirSync(pkgDir, { recursive: true });
+  for (const file of pkg.files) {
+    const filePath = path3.join(pkgDir, file.path);
+    fs3.mkdirSync(path3.dirname(filePath), { recursive: true });
+    fs3.writeFileSync(filePath, file.content, "utf-8");
+  }
+  const manifest = {
+    name: pkg.name,
+    slug: pkg.slug,
+    version: pkg.version,
+    description: pkg.description,
+    entryPoint: pkg.entry_point,
+    installedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  fs3.writeFileSync(path3.join(pkgDir, "kode.json"), JSON.stringify(manifest, null, 2) + "\n");
+  const already = isPackageInstalled(scriptsDir, pkg.slug) ? " (updated)" : "";
+  return {
+    success: true,
+    message: `\u2705 Installed @kode/${pkg.slug} v${pkg.version}${already}
+   ${pkg.files.length} file(s) \u2192 .cure-kode-scripts/packages/@kode/${pkg.slug}/
+   Import with: import { ... } from '@kode/${pkg.slug}'`,
+    data: manifest
+  };
+}
+async function pkgRemove(scriptsDir, packageSlug) {
+  const pkgDir = path3.join(getPackagesDir(scriptsDir), packageSlug);
+  if (!fs3.existsSync(pkgDir)) {
+    return { success: false, message: `Package "@kode/${packageSlug}" is not installed.` };
+  }
+  fs3.rmSync(pkgDir, { recursive: true, force: true });
+  return {
+    success: true,
+    message: `\u2705 Removed @kode/${packageSlug}`
+  };
+}
+async function pkgPublish(client, scriptsDir, options) {
+  const sourcePath = path3.join(scriptsDir, options.path);
+  if (!fs3.existsSync(sourcePath)) {
+    return { success: false, message: `Path not found: ${options.path}` };
+  }
+  const files = [];
+  const stat = fs3.statSync(sourcePath);
+  if (stat.isFile()) {
+    const ext = path3.extname(sourcePath);
+    const content = fs3.readFileSync(sourcePath, "utf-8");
+    files.push({ path: `index${ext}`, content });
+  } else if (stat.isDirectory()) {
+    collectFiles(sourcePath, sourcePath, files);
+  }
+  if (files.length === 0) {
+    return { success: false, message: `No files found at "${options.path}".` };
+  }
+  let entryPoint = options.entryPoint;
+  if (!entryPoint) {
+    const entryNames = ["index.ts", "index.tsx", "index.jsx", "index.js"];
+    const found = files.find((f) => entryNames.includes(f.path));
+    if (found) {
+      entryPoint = found.path;
+    } else {
+      entryPoint = files[0].path;
+    }
+  }
+  const displayName = options.name || options.slug.split("-").map(
+    (w) => w.charAt(0).toUpperCase() + w.slice(1)
+  ).join(" ");
+  try {
+    const result = await client.publishPackage({
+      name: displayName,
+      slug: options.slug,
+      description: options.description,
+      entryPoint,
+      files,
+      tags: options.tags
+    });
+    const verb = result.created ? "Published" : "Updated";
+    return {
+      success: true,
+      message: `\u2705 ${verb} @kode/${result.slug} v${result.version}
+   ${files.length} file(s), entry: ${entryPoint}
+   Install with: kode_pkg add ${result.slug}`,
+      data: { slug: result.slug, version: result.version, files: files.length }
+    };
+  } catch (err) {
+    return {
+      success: false,
+      message: `Failed to publish: ${err instanceof Error ? err.message : String(err)}`
+    };
+  }
+}
+async function pkgList(client, scriptsDir, options) {
+  const queryParts = [];
+  if (options?.search) queryParts.push(`search=${encodeURIComponent(options.search)}`);
+  if (options?.category) queryParts.push(`category=${encodeURIComponent(options.category)}`);
+  const qs = queryParts.length > 0 ? queryParts.join("&") : void 0;
+  const packages = await client.listPackages(qs);
+  const installed = scriptsDir ? listInstalledPackages(scriptsDir) : [];
+  if (packages.length === 0) {
+    return { success: true, message: "No packages found in the registry." };
+  }
+  const lines = packages.map((p) => {
+    const isInstalled = installed.includes(p.slug);
+    const status = isInstalled ? " \u2705" : "";
+    const tags = p.tags?.length ? ` [${p.tags.join(", ")}]` : "";
+    return `  ${p.slug} v${p.version}${status} \u2014 ${p.description || "No description"}${tags}`;
+  });
+  return {
+    success: true,
+    message: `\u{1F4E6} Packages in registry (${packages.length}):
+${lines.join("\n")}`,
+    data: packages
+  };
+}
+async function pkgInfo(client, scriptsDir, packageSlug) {
+  let pkg;
+  try {
+    pkg = await client.getPackage(packageSlug);
+  } catch {
+    return { success: false, message: `Package "${packageSlug}" not found.` };
+  }
+  const installed = scriptsDir ? isPackageInstalled(scriptsDir, pkg.slug) : false;
+  const fileList = pkg.files?.map((f) => `    ${f.path}`).join("\n") || "    (no files)";
+  const info = [
+    `\u{1F4E6} @kode/${pkg.slug} v${pkg.version}`,
+    `   Name: ${pkg.name}`,
+    pkg.description ? `   Description: ${pkg.description}` : null,
+    `   Entry: ${pkg.entry_point}`,
+    pkg.tags?.length ? `   Tags: ${pkg.tags.join(", ")}` : null,
+    `   Installs: ${pkg.install_count}`,
+    `   Status: ${installed ? "\u2705 Installed locally" : "Not installed"}`,
+    `   Files:
+${fileList}`,
+    pkg.example_usage ? `
+   Example:
+${pkg.example_usage}` : null
+  ].filter(Boolean).join("\n");
+  return { success: true, message: info, data: pkg };
+}
+async function pkgUpdate(client, scriptsDir, packageSlug) {
+  if (!isPackageInstalled(scriptsDir, packageSlug)) {
+    return { success: false, message: `Package "@kode/${packageSlug}" is not installed.` };
+  }
+  const manifestPath = path3.join(getPackagesDir(scriptsDir), packageSlug, "kode.json");
+  let currentVersion = 0;
+  if (fs3.existsSync(manifestPath)) {
+    try {
+      const manifest = JSON.parse(fs3.readFileSync(manifestPath, "utf-8"));
+      currentVersion = manifest.version || 0;
+    } catch {
+    }
+  }
+  let pkg;
+  try {
+    pkg = await client.getPackage(packageSlug);
+  } catch {
+    return { success: false, message: `Package "${packageSlug}" not found in registry.` };
+  }
+  if (pkg.version <= currentVersion) {
+    return { success: true, message: `@kode/${packageSlug} is already up to date (v${currentVersion}).` };
+  }
+  return pkgAdd(client, scriptsDir, packageSlug);
+}
+function collectFiles(baseDir, currentDir, files) {
+  for (const entry of fs3.readdirSync(currentDir, { withFileTypes: true })) {
+    const fullPath = path3.join(currentDir, entry.name);
+    if (entry.isDirectory()) {
+      if (!["node_modules", ".git", "dist"].includes(entry.name)) {
+        collectFiles(baseDir, fullPath, files);
+      }
+    } else if (entry.isFile()) {
+      const relativePath = path3.relative(baseDir, fullPath);
+      const content = fs3.readFileSync(fullPath, "utf-8");
+      files.push({ path: relativePath, content });
+    }
+  }
+}
+
 // src/api.ts
 var KodeApiClient = class {
   apiUrl;
@@ -18,8 +399,8 @@ var KodeApiClient = class {
     this.apiUrl = apiUrl.replace(/\/$/, "");
     this.apiKey = apiKey;
   }
-  async request(path3, options = {}) {
-    const url = `${this.apiUrl}${path3}`;
+  async request(path6, options = {}) {
+    const url = `${this.apiUrl}${path6}`;
     const headers = {
       "Content-Type": "application/json",
       "X-API-Key": this.apiKey,
@@ -154,6 +535,33 @@ var KodeApiClient = class {
       body: JSON.stringify({ siteId, url })
     });
   }
+  // Library operations
+  async listLibrary(queryString) {
+    return this.request(`/api/cdn/library${queryString || ""}`);
+  }
+  async getLibrarySnippet(slugOrId) {
+    return this.request(`/api/cdn/library/${encodeURIComponent(slugOrId)}`);
+  }
+  async createLibrarySnippet(data) {
+    return this.request("/api/cdn/library", {
+      method: "POST",
+      body: JSON.stringify(data)
+    });
+  }
+  async updateLibrarySnippet(slugOrId, data) {
+    return this.request(`/api/cdn/library/${encodeURIComponent(slugOrId)}`, {
+      method: "PATCH",
+      body: JSON.stringify(data)
+    });
+  }
+  async deleteLibrarySnippet(slugOrId) {
+    await this.request(`/api/cdn/library/${encodeURIComponent(slugOrId)}`, {
+      method: "DELETE"
+    });
+  }
+  async listLibraryFolders() {
+    return this.request("/api/cdn/library/folders");
+  }
   // Validate API key
   async validateKey() {
     try {
@@ -173,32 +581,60 @@ var KodeApiClient = class {
   async getScriptMetadata(scriptId) {
     return this.request(`/api/cdn/scripts/${scriptId}/metadata`);
   }
+  // ==================== Packages ====================
+  async listPackages(queryString) {
+    const qs = queryString ? `?${queryString}` : "";
+    return this.request(`/api/cdn/packages${qs}`);
+  }
+  async getPackage(slugOrId) {
+    return this.request(`/api/cdn/packages/${slugOrId}`);
+  }
+  async publishPackage(data) {
+    return this.request("/api/cdn/packages", {
+      method: "POST",
+      body: JSON.stringify(data)
+    });
+  }
+  async updatePackage(slugOrId, data) {
+    return this.request(`/api/cdn/packages/${slugOrId}`, {
+      method: "PATCH",
+      body: JSON.stringify(data)
+    });
+  }
+  async deletePackage(slugOrId) {
+    return this.request(`/api/cdn/packages/${slugOrId}`, {
+      method: "DELETE"
+    });
+  }
+  async getCmsTypes(siteId) {
+    return this.request(`/api/cdn/sites/${siteId}/cms-types`);
+  }
 };
 
 // src/config.ts
-import * as fs from "fs";
-import * as path from "path";
+import * as fs4 from "fs";
+import * as path4 from "path";
 var DEFAULT_API_URL = "https://app.cure.no";
 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)) {
+  while (currentDir !== path4.dirname(currentDir)) {
+    const configPath = path4.join(currentDir, CONFIG_DIR, CONFIG_FILE);
+    if (fs4.existsSync(configPath)) {
       return currentDir;
     }
-    currentDir = path.dirname(currentDir);
+    currentDir = path4.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;
+  const configPath = path4.join(projectRoot, CONFIG_DIR, CONFIG_FILE);
+  if (!fs4.existsSync(configPath)) return void 0;
   try {
-    const content = fs.readFileSync(configPath, "utf-8");
+    const content = fs4.readFileSync(configPath, "utf-8");
     return JSON.parse(content);
   } catch {
     return void 0;
@@ -235,22 +671,22 @@ function getScriptsDir() {
   const projectRoot = findProjectRoot();
   const projectConfig = loadProjectConfig();
   if (!projectRoot || !projectConfig) return void 0;
-  return path.join(projectRoot, projectConfig.scriptsDir);
+  return path4.join(projectRoot, projectConfig.scriptsDir);
 }
 function getContextPath() {
   const projectRoot = findProjectRoot();
   if (!projectRoot) return void 0;
-  return path.join(projectRoot, CONFIG_DIR, "context.md");
+  return path4.join(projectRoot, CONFIG_DIR, "context.md");
 }
 function getPagesDir() {
   const projectRoot = findProjectRoot();
   if (!projectRoot) return void 0;
-  return path.join(projectRoot, CONFIG_DIR, "pages");
+  return path4.join(projectRoot, CONFIG_DIR, "pages");
 }
 
 // src/index.ts
-import * as fs2 from "fs";
-import * as path2 from "path";
+import * as fs5 from "fs";
+import * as path5 from "path";
 function urlToSlug(url) {
   try {
     const parsed = new URL(url);
@@ -329,7 +765,7 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
       },
       {
         name: "kode_create_script",
-        description: "Create a new script entry (metadata only). After creating, write the script file locally to .cure-kode-scripts/{name}.js and use kode_push to upload content. This keeps script content out of MCP context.",
+        description: "Create a new script entry (metadata only). After creating, write the script file locally to .cure-kode-scripts/{name}.{ext} and use kode_push to upload content. Supports JS, TS, TSX, JSX, and CSS files.",
         inputSchema: {
           type: "object",
           properties: {
@@ -340,7 +776,12 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
             type: {
               type: "string",
               enum: ["javascript", "css"],
-              description: "Script type"
+              description: 'Script type (CDN type). Use "javascript" for JS/TS/TSX/JSX files.'
+            },
+            sourceType: {
+              type: "string",
+              enum: ["js", "ts", "tsx", "jsx", "css"],
+              description: 'Source file extension. Determines the local file type. Default: "js" for javascript, "css" for css.'
             },
             scope: {
               type: "string",
@@ -832,6 +1273,169 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
           },
           required: []
         }
+      },
+      {
+        name: "kode_library_list",
+        description: "List all snippets in the global Kode library (Bibliotek). Returns reusable code patterns like GSAP animations, form handlers, scroll effects. Use this before writing common patterns from scratch.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            category: {
+              type: "string",
+              description: "Filter by category: animations, forms, utilities, tracking, analytics, consent, integrations, other"
+            },
+            search: {
+              type: "string",
+              description: "Search by name or tags"
+            },
+            folder: {
+              type: "string",
+              description: "Filter by folder ID"
+            }
+          },
+          required: []
+        }
+      },
+      {
+        name: "kode_library_get",
+        description: "Get a library snippet by slug or ID. Returns full code, description, tags, example usage, and version.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            slug: {
+              type: "string",
+              description: "Snippet slug or ID"
+            }
+          },
+          required: ["slug"]
+        }
+      },
+      {
+        name: "kode_library_use",
+        description: "Copy a library snippet into the current project as a new script file. The snippet code is written to .cure-kode-scripts/{slug}.{ext}. Use kode_push afterwards to upload to CDN.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            snippetSlug: {
+              type: "string",
+              description: "Library snippet slug to copy"
+            },
+            newName: {
+              type: "string",
+              description: "Optional new filename (without extension). Defaults to the snippet slug."
+            }
+          },
+          required: ["snippetSlug"]
+        }
+      },
+      {
+        name: "kode_library_create",
+        description: "Create a new snippet in the global Kode library. Requires a unique slug.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            name: { type: "string", description: "Display name" },
+            slug: { type: "string", description: "URL-safe slug (must be unique)" },
+            type: { type: "string", enum: ["javascript", "css"], description: "Script type" },
+            code: { type: "string", description: "Script code" },
+            description: { type: "string", description: "Short description" },
+            category: { type: "string", description: "Category: animations, forms, utilities, tracking, analytics, consent, integrations, other" },
+            tags: { type: "array", items: { type: "string" }, description: "Tags for discovery" },
+            folderId: { type: "string", description: "Target folder ID" }
+          },
+          required: ["name", "slug", "type", "code"]
+        }
+      },
+      {
+        name: "kode_library_update",
+        description: "Update an existing library snippet (code, metadata, or both). Version auto-increments when code changes.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            slug: { type: "string", description: "Snippet slug or ID" },
+            code: { type: "string", description: "New code (triggers version bump)" },
+            name: { type: "string", description: "New display name" },
+            description: { type: "string", description: "New description" },
+            category: { type: "string", description: "New category" },
+            tags: { type: "array", items: { type: "string" }, description: "New tags" },
+            folderId: { type: ["string", "null"], description: "Move to folder (null = root)" }
+          },
+          required: ["slug"]
+        }
+      },
+      {
+        name: "kode_library_delete",
+        description: "Soft-delete a library snippet (moves to trash, recoverable for 30 days).",
+        inputSchema: {
+          type: "object",
+          properties: {
+            slug: { type: "string", description: "Snippet slug or ID to delete" }
+          },
+          required: ["slug"]
+        }
+      },
+      {
+        name: "kode_library_folders",
+        description: "List all folders in the Kode library. Returns folder hierarchy with snippet counts.",
+        inputSchema: {
+          type: "object",
+          properties: {},
+          required: []
+        }
+      },
+      {
+        name: "kode_pkg",
+        description: "Package manager for Cure Kode. Like npm but for @kode/* packages. Actions: add (install a package), remove (uninstall), publish (upload a component to registry), list (browse registry), info (package details), update (update installed package).",
+        inputSchema: {
+          type: "object",
+          properties: {
+            action: {
+              type: "string",
+              enum: ["add", "remove", "publish", "list", "info", "update"],
+              description: "The action to perform."
+            },
+            name: {
+              type: "string",
+              description: "Package slug. Required for add, remove, info, update."
+            },
+            // publish-specific options
+            path: {
+              type: "string",
+              description: 'For publish: path relative to .cure-kode-scripts/ (e.g., "components/Button" or "lib/utils.ts").'
+            },
+            slug: {
+              type: "string",
+              description: "For publish: package slug to publish as."
+            },
+            displayName: {
+              type: "string",
+              description: "For publish: human-readable name."
+            },
+            description: {
+              type: "string",
+              description: "For publish: package description."
+            },
+            entryPoint: {
+              type: "string",
+              description: "For publish: entry point file (auto-detected if not set)."
+            },
+            tags: {
+              type: "array",
+              items: { type: "string" },
+              description: "For publish: tags for discoverability."
+            },
+            // list-specific options
+            search: {
+              type: "string",
+              description: "For list: search query."
+            },
+            category: {
+              type: "string",
+              description: "For list: filter by category."
+            }
+          },
+          required: ["action"]
+        }
       }
     ]
   };
@@ -935,7 +1539,7 @@ ${script.content}`
         };
       }
       case "kode_create_script": {
-        const { name: scriptName, type, scope, autoLoad, purpose } = args;
+        const { name: scriptName, type, sourceType, scope, autoLoad, purpose } = args;
         const scriptScope = scope || "global";
         const script = await client.createScript(siteId, {
           name: scriptName,
@@ -948,7 +1552,7 @@ ${script.content}`
           metadata: purpose ? { purpose } : void 0
         });
         const scriptsDir = getScriptsDir();
-        const ext = type === "javascript" ? "js" : "css";
+        const ext = sourceType || (type === "javascript" ? "js" : "css");
         const localPath = scriptsDir ? `${scriptsDir}/${scriptName}.${ext}` : `.cure-kode-scripts/${scriptName}.${ext}`;
         let responseText = `Created script "${script.name}" (${script.type})`;
         responseText += `
@@ -957,6 +1561,10 @@ Slug: ${script.slug}`;
 Scope: ${script.scope}`;
         responseText += `
 Auto-load: ${script.auto_load ? "yes" : "no"}`;
+        if (sourceType && sourceType !== "js" && sourceType !== "css") {
+          responseText += `
+Source type: ${sourceType.toUpperCase()}`;
+        }
         if (purpose) responseText += `
 Purpose: ${purpose}`;
         responseText += `
@@ -965,7 +1573,7 @@ Next steps:`;
         responseText += `
 1. Create file: ${localPath}`;
         responseText += `
-2. Write your ${type} code`;
+2. Write your ${ext.toUpperCase()} code`;
         responseText += `
 3. Run kode_push to upload content`;
         responseText += `
@@ -982,7 +1590,7 @@ Next steps:`;
       case "kode_push": {
         const { scriptSlug, force } = args;
         const scriptsDir = getScriptsDir();
-        if (!scriptsDir || !fs2.existsSync(scriptsDir)) {
+        if (!scriptsDir || !fs5.existsSync(scriptsDir)) {
           return {
             content: [{
               type: "text",
@@ -992,23 +1600,21 @@ Next steps:`;
           };
         }
         const remoteScripts = await client.listScripts(siteId);
-        const localFiles = fs2.readdirSync(scriptsDir).filter((f) => f.endsWith(".js") || f.endsWith(".css"));
+        const entryFiles = getEntryFiles(scriptsDir);
         if (scriptSlug) {
-          const ext = remoteScripts.find((s) => s.slug === scriptSlug)?.type === "css" ? "css" : "js";
-          const fileName = `${scriptSlug}.${ext}`;
-          const filePath = path2.join(scriptsDir, fileName);
-          if (!fs2.existsSync(filePath)) {
+          const entry = entryFiles.find((f) => f.slug === scriptSlug);
+          if (!entry) {
+            const available = entryFiles.map((f) => f.fileName).join(", ") || "(none)";
             return {
               content: [{
                 type: "text",
-                text: `File not found: ${filePath}
+                text: `No entry file found for slug "${scriptSlug}"
 
-Available files: ${localFiles.join(", ") || "(none)"}`
+Available entry files: ${available}`
               }],
               isError: true
             };
           }
-          const content = fs2.readFileSync(filePath, "utf-8");
           const remote = remoteScripts.find((s) => s.slug === scriptSlug);
           if (!remote) {
             return {
@@ -1019,6 +1625,36 @@ Available files: ${localFiles.join(", ") || "(none)"}`
               isError: true
             };
           }
+          const sourceContent = fs5.readFileSync(entry.filePath, "utf-8");
+          let content = sourceContent;
+          let bundleNote = "";
+          let usesReact = false;
+          if (entry.needsBundling) {
+            const aliases2 = getPackageAliases(scriptsDir);
+            const result = await bundleEntryPoint({
+              entryPoint: entry.filePath,
+              scriptsDir,
+              packageAliases: aliases2
+            });
+            if (result.errors.length > 0) {
+              return {
+                content: [{
+                  type: "text",
+                  text: `Build failed for "${scriptSlug}":
+
+${result.errors.join("\n")}`
+                }],
+                isError: true
+              };
+            }
+            content = result.code;
+            usesReact = result.usesReact;
+            bundleNote = `
+\u{1F4E6} Bundled from ${entry.ext.toUpperCase()}: ${result.size} bytes`;
+            if (usesReact) bundleNote += " (uses React)";
+            if (result.warnings.length > 0) bundleNote += `
+\u26A0\uFE0F ${result.warnings.join(", ")}`;
+          }
           if (!force && remote.content === content) {
             return {
               content: [{
@@ -1027,14 +1663,20 @@ Available files: ${localFiles.join(", ") || "(none)"}`
               }]
             };
           }
+          const existingMetadata = remote.metadata || {};
           const updated = await client.updateScript(remote.id, {
             content,
-            changeSummary: "Pushed via MCP"
+            changeSummary: `Pushed via MCP (${entry.ext})`,
+            ...entry.needsBundling ? {
+              metadata: { ...existingMetadata, usesReact },
+              sourceContent,
+              sourceType: entry.ext
+            } : {}
           });
           return {
             content: [{
               type: "text",
-              text: `Pushed "${scriptSlug}": ${content.length} chars \u2192 v${updated.current_version}
+              text: `Pushed "${scriptSlug}": ${content.length} chars \u2192 v${updated.current_version}${bundleNote}
 
 Run kode_deploy to make changes live.`
             }]
@@ -1043,28 +1685,48 @@ Run kode_deploy to make changes live.`
         const results = [];
         let pushedCount = 0;
         let skippedCount = 0;
-        for (const file of localFiles) {
-          const slug = file.replace(/\.(js|css)$/, "");
-          const filePath = path2.join(scriptsDir, file);
-          const content = fs2.readFileSync(filePath, "utf-8");
-          const remote = remoteScripts.find((s) => s.slug === slug);
+        const aliases = getPackageAliases(scriptsDir);
+        for (const entry of entryFiles) {
+          const remote = remoteScripts.find((s) => s.slug === entry.slug);
           if (!remote) {
-            results.push(`\u26A0\uFE0F ${slug}: not on server (create with kode_create_script first)`);
+            results.push(`\u26A0\uFE0F ${entry.slug}: not on server (create with kode_create_script first)`);
             continue;
           }
+          const sourceContent = fs5.readFileSync(entry.filePath, "utf-8");
+          let content = sourceContent;
+          let usesReact = false;
+          if (entry.needsBundling) {
+            const bundleResult = await bundleEntryPoint({
+              entryPoint: entry.filePath,
+              scriptsDir,
+              packageAliases: aliases
+            });
+            if (bundleResult.errors.length > 0) {
+              results.push(`\u2717 ${entry.slug}: build failed: ${bundleResult.errors[0]}`);
+              continue;
+            }
+            content = bundleResult.code;
+            usesReact = bundleResult.usesReact;
+          }
           if (!force && remote.content === content) {
             skippedCount++;
             continue;
           }
           try {
+            const existingMeta = remote.metadata || {};
             const updated = await client.updateScript(remote.id, {
               content,
-              changeSummary: "Pushed via MCP"
+              changeSummary: `Pushed via MCP (${entry.ext})`,
+              ...entry.needsBundling ? {
+                metadata: { ...existingMeta, usesReact },
+                sourceContent,
+                sourceType: entry.ext
+              } : {}
             });
-            results.push(`\u2713 ${slug}: ${content.length} chars \u2192 v${updated.current_version}`);
+            results.push(`\u2713 ${entry.slug}: ${content.length} chars \u2192 v${updated.current_version}`);
             pushedCount++;
           } catch (err) {
-            results.push(`\u2717 ${slug}: ${err instanceof Error ? err.message : "failed"}`);
+            results.push(`\u2717 ${entry.slug}: ${err instanceof Error ? err.message : "failed"}`);
           }
         }
         let responseText = `Push complete: ${pushedCount} updated, ${skippedCount} unchanged`;
@@ -1905,13 +2567,13 @@ Last analyzed: ${result.lastAnalyzed}`;
             isError: true
           };
         }
-        if (!fs2.existsSync(contextPath)) {
+        if (!fs5.existsSync(contextPath)) {
           return {
             content: [{ type: "text", text: 'No context file found. Run "kode context --refresh" to create one.' }],
             isError: true
           };
         }
-        const content = fs2.readFileSync(contextPath, "utf-8");
+        const content = fs5.readFileSync(contextPath, "utf-8");
         return {
           content: [{ type: "text", text: content }]
         };
@@ -1924,14 +2586,14 @@ Last analyzed: ${result.lastAnalyzed}`;
             isError: true
           };
         }
-        if (!fs2.existsSync(contextPath)) {
+        if (!fs5.existsSync(contextPath)) {
           return {
             content: [{ type: "text", text: 'No context file found. Run "kode context --refresh" to create one.' }],
             isError: true
           };
         }
         const { addNote, addSession, updateScriptPurpose } = args;
-        let content = fs2.readFileSync(contextPath, "utf-8");
+        let content = fs5.readFileSync(contextPath, "utf-8");
         const updates = [];
         const timestamp = (/* @__PURE__ */ new Date()).toISOString();
         content = content.replace(
@@ -1992,7 +2654,7 @@ ${sessionMd}`
             updates.push(`Updated purpose for "${slug}": "${purpose}"`);
           }
         }
-        fs2.writeFileSync(contextPath, content, "utf-8");
+        fs5.writeFileSync(contextPath, content, "utf-8");
         return {
           content: [
             {
@@ -2100,10 +2762,10 @@ ${result.htmlPreview.slice(0, 5e3)}`;
           };
         }
         const slug = urlToSlug(url);
-        const cachePath = path2.join(pagesDir, `${slug}.json`);
-        if (!force && fs2.existsSync(cachePath)) {
+        const cachePath = path5.join(pagesDir, `${slug}.json`);
+        if (!force && fs5.existsSync(cachePath)) {
           try {
-            const cached = JSON.parse(fs2.readFileSync(cachePath, "utf-8"));
+            const cached = JSON.parse(fs5.readFileSync(cachePath, "utf-8"));
             return {
               content: [{
                 type: "text",
@@ -2143,12 +2805,12 @@ CMS Collections: ${cached.cmsPatterns.length}`
           };
         }
         const structure = await response.json();
-        if (!fs2.existsSync(pagesDir)) {
-          fs2.mkdirSync(pagesDir, { recursive: true });
+        if (!fs5.existsSync(pagesDir)) {
+          fs5.mkdirSync(pagesDir, { recursive: true });
         }
-        fs2.writeFileSync(cachePath, JSON.stringify(structure, null, 2), "utf-8");
+        fs5.writeFileSync(cachePath, JSON.stringify(structure, null, 2), "utf-8");
         const contextPath = getContextPath();
-        if (contextPath && fs2.existsSync(contextPath)) {
+        if (contextPath && fs5.existsSync(contextPath)) {
         }
         let text = `Page cached: ${slug}
 Path: ${cachePath}
@@ -2216,8 +2878,8 @@ CMS Collections (${structure.cmsPatterns.length}):
           };
         }
         const slug = urlOrSlug.startsWith("http") ? urlToSlug(urlOrSlug) : urlOrSlug;
-        const cachePath = path2.join(pagesDir, `${slug}.json`);
-        if (!fs2.existsSync(cachePath)) {
+        const cachePath = path5.join(pagesDir, `${slug}.json`);
+        if (!fs5.existsSync(cachePath)) {
           return {
             content: [{
               type: "text",
@@ -2228,7 +2890,7 @@ Use kode_list_pages_context to see cached pages, or kode_refresh_page to cache a
             isError: true
           };
         }
-        const context = JSON.parse(fs2.readFileSync(cachePath, "utf-8"));
+        const context = JSON.parse(fs5.readFileSync(cachePath, "utf-8"));
         const cacheAge = Date.now() - new Date(context.extractedAt).getTime();
         const cacheAgeDays = Math.floor(cacheAge / (1e3 * 60 * 60 * 24));
         const isStale = cacheAgeDays > 7;
@@ -2472,7 +3134,7 @@ Use kode_list_pages_context to see cached pages, or kode_refresh_page to cache a
             isError: true
           };
         }
-        if (!fs2.existsSync(pagesDir)) {
+        if (!fs5.existsSync(pagesDir)) {
           return {
             content: [{
               type: "text",
@@ -2480,7 +3142,7 @@ Use kode_list_pages_context to see cached pages, or kode_refresh_page to cache a
             }]
           };
         }
-        const files = fs2.readdirSync(pagesDir).filter((f) => f.endsWith(".json"));
+        const files = fs5.readdirSync(pagesDir).filter((f) => f.endsWith(".json"));
         if (files.length === 0) {
           return {
             content: [{
@@ -2495,7 +3157,7 @@ Use kode_list_pages_context to see cached pages, or kode_refresh_page to cache a
         for (const file of files) {
           const slug = file.replace(".json", "");
           try {
-            const context = JSON.parse(fs2.readFileSync(path2.join(pagesDir, file), "utf-8"));
+            const context = JSON.parse(fs5.readFileSync(path5.join(pagesDir, file), "utf-8"));
             const urlPath = new URL(context.url).pathname;
             text += `${urlPath} [${slug}]
 `;
@@ -2576,8 +3238,8 @@ Use kode_list_pages_context to see cached pages, or kode_refresh_page to cache a
             text += "\n";
           }
           if (updateClaudeMd) {
-            const kodeMdPath = path2.join(projectRoot, ".cure-kode", "KODE.md");
-            const claudeMdPath = path2.join(projectRoot, "CLAUDE.md");
+            const kodeMdPath = path5.join(projectRoot, ".cure-kode", "KODE.md");
+            const claudeMdPath = path5.join(projectRoot, "CLAUDE.md");
             const siteName = config.siteName || "Site";
             const siteSlug = config.siteSlug || "site";
             let kodeMd = `# Cure Kode: ${siteName}
@@ -2597,7 +3259,7 @@ Use kode_list_pages_context to see cached pages, or kode_refresh_page to cache a
             kodeMd += `## CDN URL
 
 \`\`\`html
-<script defer src="https://app.cure.no/api/cdn/${siteSlug}/init.js"></script>
+<script src="https://app.cure.no/api/cdn/${siteSlug}/init.js"></script>
 \`\`\`
 
 ---
@@ -2652,7 +3314,7 @@ Use kode_list_pages_context to see cached pages, or kode_refresh_page to cache a
 `;
             kodeMd += `**Check for updates:** \`kode doctor\`
 `;
-            fs2.writeFileSync(kodeMdPath, kodeMd);
+            fs5.writeFileSync(kodeMdPath, kodeMd);
             text += `Updated .cure-kode/KODE.md with current scripts and pages.
 `;
             const kodeReference = `## Cure Kode
@@ -2668,16 +3330,16 @@ Full documentation: [.cure-kode/KODE.md](.cure-kode/KODE.md)
 ---
 
 `;
-            if (fs2.existsSync(claudeMdPath)) {
-              const claudeContent = fs2.readFileSync(claudeMdPath, "utf-8");
+            if (fs5.existsSync(claudeMdPath)) {
+              const claudeContent = fs5.readFileSync(claudeMdPath, "utf-8");
               const hasReference = claudeContent.includes("KODE.md") || claudeContent.includes(".cure-kode/KODE.md");
               if (!hasReference) {
-                fs2.writeFileSync(claudeMdPath, kodeReference + claudeContent);
+                fs5.writeFileSync(claudeMdPath, kodeReference + claudeContent);
                 text += `Added Kode reference to CLAUDE.md.
 `;
               }
             } else {
-              fs2.writeFileSync(claudeMdPath, kodeReference);
+              fs5.writeFileSync(claudeMdPath, kodeReference);
               text += `Created CLAUDE.md with Kode reference.
 `;
             }
@@ -2693,6 +3355,147 @@ Full documentation: [.cure-kode/KODE.md](.cure-kode/KODE.md)
           };
         }
       }
+      case "kode_library_list": {
+        const { category, search, folder } = args;
+        const params = new URLSearchParams();
+        if (category) params.set("category", category);
+        if (search) params.set("search", search);
+        if (folder) params.set("folder", folder);
+        const snippets = await client.listLibrary(params.toString() ? `?${params.toString()}` : "");
+        return {
+          content: [{ type: "text", text: JSON.stringify(snippets, null, 2) }]
+        };
+      }
+      case "kode_library_get": {
+        const { slug } = args;
+        const snippet = await client.getLibrarySnippet(slug);
+        return {
+          content: [{ type: "text", text: JSON.stringify(snippet, null, 2) }]
+        };
+      }
+      case "kode_library_use": {
+        const { snippetSlug, newName } = args;
+        const snippet = await client.getLibrarySnippet(snippetSlug);
+        const fileName = newName || snippet.slug;
+        const ext = snippet.type === "javascript" ? "js" : "css";
+        const scriptsDir = getScriptsDir();
+        if (!scriptsDir) {
+          return {
+            content: [{ type: "text", text: "Scripts directory not found. Run `kode init` first." }],
+            isError: true
+          };
+        }
+        const filePath = path5.join(scriptsDir, `${fileName}.${ext}`);
+        if (fs5.existsSync(filePath)) {
+          return {
+            content: [{ type: "text", text: `File already exists: ${fileName}.${ext}. Use a different newName or delete the existing file.` }],
+            isError: true
+          };
+        }
+        if (!fs5.existsSync(scriptsDir)) {
+          fs5.mkdirSync(scriptsDir, { recursive: true });
+        }
+        fs5.writeFileSync(filePath, snippet.code);
+        return {
+          content: [{ type: "text", text: `Copied "${snippet.name}" to ${fileName}.${ext}
+
+Run \`kode push\` to upload to CDN.` }]
+        };
+      }
+      case "kode_library_create": {
+        const { name: name2, slug, type, code, description, category, tags, folderId } = args;
+        const result = await client.createLibrarySnippet({
+          name: name2,
+          slug,
+          type,
+          code,
+          description,
+          category,
+          tags,
+          folderId
+        });
+        return {
+          content: [{ type: "text", text: `Created library snippet "${name2}" (${result.slug})` }]
+        };
+      }
+      case "kode_library_update": {
+        const { slug, ...updates } = args;
+        const result = await client.updateLibrarySnippet(slug, updates);
+        return {
+          content: [{ type: "text", text: `Updated library snippet "${result.slug}" (now v${result.version})` }]
+        };
+      }
+      case "kode_library_delete": {
+        const { slug } = args;
+        await client.deleteLibrarySnippet(slug);
+        return {
+          content: [{ type: "text", text: `Soft-deleted library snippet "${slug}". It can be restored from trash within 30 days.` }]
+        };
+      }
+      case "kode_library_folders": {
+        const folders = await client.listLibraryFolders();
+        return {
+          content: [{ type: "text", text: JSON.stringify(folders, null, 2) }]
+        };
+      }
+      case "kode_pkg": {
+        const action = args?.action;
+        const scriptsDir = getScriptsDir();
+        switch (action) {
+          case "add": {
+            const pkgName = args?.name;
+            if (!pkgName) return { content: [{ type: "text", text: "Error: name is required for add." }], isError: true };
+            if (!scriptsDir) return { content: [{ type: "text", text: "Error: Not in a Kode project. Run kode init first." }], isError: true };
+            const result = await pkgAdd(client, scriptsDir, pkgName);
+            return { content: [{ type: "text", text: result.message }], isError: !result.success };
+          }
+          case "remove": {
+            const pkgName = args?.name;
+            if (!pkgName) return { content: [{ type: "text", text: "Error: name is required for remove." }], isError: true };
+            if (!scriptsDir) return { content: [{ type: "text", text: "Error: Not in a Kode project." }], isError: true };
+            const result = await pkgRemove(scriptsDir, pkgName);
+            return { content: [{ type: "text", text: result.message }], isError: !result.success };
+          }
+          case "publish": {
+            const pubPath = args?.path;
+            const pubSlug = args?.slug || args?.name;
+            if (!pubPath) return { content: [{ type: "text", text: "Error: path is required for publish." }], isError: true };
+            if (!pubSlug) return { content: [{ type: "text", text: "Error: slug (or name) is required for publish." }], isError: true };
+            if (!scriptsDir) return { content: [{ type: "text", text: "Error: Not in a Kode project." }], isError: true };
+            const result = await pkgPublish(client, scriptsDir, {
+              path: pubPath,
+              slug: pubSlug,
+              name: args?.displayName,
+              description: args?.description,
+              entryPoint: args?.entryPoint,
+              tags: args?.tags
+            });
+            return { content: [{ type: "text", text: result.message }], isError: !result.success };
+          }
+          case "list": {
+            const result = await pkgList(client, scriptsDir, {
+              search: args?.search,
+              category: args?.category
+            });
+            return { content: [{ type: "text", text: result.message }] };
+          }
+          case "info": {
+            const pkgName = args?.name;
+            if (!pkgName) return { content: [{ type: "text", text: "Error: name is required for info." }], isError: true };
+            const result = await pkgInfo(client, scriptsDir, pkgName);
+            return { content: [{ type: "text", text: result.message }], isError: !result.success };
+          }
+          case "update": {
+            const pkgName = args?.name;
+            if (!pkgName) return { content: [{ type: "text", text: "Error: name is required for update." }], isError: true };
+            if (!scriptsDir) return { content: [{ type: "text", text: "Error: Not in a Kode project." }], isError: true };
+            const result = await pkgUpdate(client, scriptsDir, pkgName);
+            return { content: [{ type: "text", text: result.message }], isError: !result.success };
+          }
+          default:
+            return { content: [{ type: "text", text: `Unknown kode_pkg action: "${action}". Use: add, remove, publish, list, info, update.` }], isError: true };
+        }
+      }
       default:
         return {
           content: [{ type: "text", text: `Unknown tool: ${name}` }],
@@ -2713,14 +3516,15 @@ Full documentation: [.cure-kode/KODE.md](.cure-kode/KODE.md)
 });
 server.setRequestHandler(ListResourcesRequestSchema, async () => {
   const scriptsDir = getScriptsDir();
-  if (!scriptsDir || !fs2.existsSync(scriptsDir)) {
+  if (!scriptsDir || !fs5.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"
+  const entries = getEntryFiles(scriptsDir);
+  const modules = getModuleFiles(scriptsDir);
+  const resources = [...entries, ...modules].map((f) => ({
+    uri: `file://${f.filePath}`,
+    name: f.isModule ? f.relativePath : f.fileName,
+    mimeType: mimeTypeFromFileName(f.fileName)
   }));
   return { resources };
 });
@@ -2730,11 +3534,11 @@ server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
     throw new Error("Invalid resource URI");
   }
   const filePath = uri.replace("file://", "");
-  if (!fs2.existsSync(filePath)) {
+  if (!fs5.existsSync(filePath)) {
     throw new Error("File not found");
   }
-  const content = fs2.readFileSync(filePath, "utf-8");
-  const mimeType = filePath.endsWith(".js") ? "application/javascript" : "text/css";
+  const content = fs5.readFileSync(filePath, "utf-8");
+  const mimeType = mimeTypeFromFileName(filePath);
   return {
     contents: [
       {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@curenorway/kode-mcp",
-  "version": "1.7.0",
+  "version": "2.0.0",
   "description": "MCP server for Cure Kode CDN - enables AI agents to manage, deploy, and analyze Webflow scripts",
   "type": "module",
   "bin": {
@@ -18,7 +18,8 @@
     "prepublishOnly": "pnpm build"
   },
   "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.0.0"
+    "@modelcontextprotocol/sdk": "^1.0.0",
+    "esbuild": "^0.24.2"
   },
   "devDependencies": {
     "@types/node": "^20.10.0",