@ourroadmaps/mcp 0.15.0 → 0.17.0

package/dist/index.js

@@ -1,4 +1,22 @@
 #!/usr/bin/env node
+import { createRequire } from "node:module";
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
 // src/index.ts
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
@@ -370,6 +388,14 @@ var wireframeSchema = z8.object({
   imageUrl: z8.string().nullable(),
   order: z8.number().int()
 });
+var prototypeSchema = z8.object({
+  id: z8.string().uuid(),
+  publicUrl: z8.string().url(),
+  expiresAt: z8.string().datetime(),
+  fileCount: z8.number().int().positive(),
+  entryPoint: z8.string(),
+  createdAt: z8.string().datetime()
+});
 var featureLinkSchema = z8.object({
   id: z8.string().uuid(),
   featureId: z8.string().uuid(),
@@ -400,6 +426,7 @@ var phaseReleaseSchema = z8.object({
 var roadmapDetailSchema = roadmapSchema.extend({
   prd: prdSchema.nullable(),
   wireframes: z8.array(wireframeSchema),
+  prototypes: z8.array(prototypeSchema),
   brainstormMedia: z8.array(brainstormMediaSchema),
   brainstormNotes: z8.string().nullable(),
   featureLinks: z8.array(featureLinkSchema),
@@ -509,8 +536,14 @@ class ApiClient {
       searchParams.set("limit", String(params.limit));
     if (params?.offset)
       searchParams.set("offset", String(params.offset));
-    const query = searchParams.toString();
-    const path = query ? `/v1/roadmaps?${query}` : "/v1/roadmaps";
+    if (params?.horizon)
+      searchParams.set("horizon", params.horizon);
+    if (params?.status)
+      searchParams.set("status", params.status);
+    if (params?.query)
+      searchParams.set("query", params.query);
+    const queryString = searchParams.toString();
+    const path = queryString ? `/v1/roadmaps?${queryString}` : "/v1/roadmaps";
     return await this.request(path);
   }
   async getRoadmap(id) {
@@ -896,6 +929,32 @@ class ApiClient {
     });
     return response.data;
   }
+  async getPrototypeUploadUrls(roadmapId, files) {
+    const response = await this.request(`/v1/roadmaps/${roadmapId}/prototypes/upload-urls`, {
+      method: "POST",
+      body: JSON.stringify({ files })
+    });
+    return response.data;
+  }
+  async createPrototype(roadmapId, data) {
+    const response = await this.request(`/v1/roadmaps/${roadmapId}/prototypes`, {
+      method: "POST",
+      body: JSON.stringify(data)
+    });
+    return response.data;
+  }
+  async uploadFile(uploadUrl, content, contentType) {
+    const response = await fetch(uploadUrl, {
+      method: "PUT",
+      body: content,
+      headers: {
+        "Content-Type": contentType
+      }
+    });
+    if (!response.ok) {
+      throw new Error(`Upload failed: ${response.status} ${response.statusText}`);
+    }
+  }
 }
 var client = null;
 function getApiClient() {
@@ -972,6 +1031,7 @@ function registerAllTools(server) {
   registerDeleteProductDesignMedia(server);
   registerUploadDesignWalkthrough(server);
   registerUploadReleaseWalkthrough(server);
+  registerPublishPrototype(server);
 }
 function registerSearchRoadmaps(server) {
   server.registerTool("search_roadmaps", {
@@ -991,24 +1051,19 @@ function registerSearchRoadmaps(server) {
     offset
   }) => {
     const client2 = getApiClient();
-    const response = await client2.listRoadmaps({ limit, offset });
-    let roadmaps = response.items;
-    if (query) {
-      const q = query.toLowerCase();
-      roadmaps = roadmaps.filter((r) => r.title.toLowerCase().includes(q));
-    }
-    if (status) {
-      roadmaps = roadmaps.filter((r) => r.status === status);
-    }
-    if (horizon) {
-      roadmaps = roadmaps.filter((r) => r.horizon === horizon);
-    }
+    const response = await client2.listRoadmaps({
+      limit,
+      offset,
+      query,
+      status,
+      horizon
+    });
     return {
       content: [
         {
           type: "text",
           text: JSON.stringify({
-            items: roadmaps.map((r) => ({
+            items: response.items.map((r) => ({
               id: r.id,
               title: r.title,
               status: r.status,
@@ -2840,6 +2895,183 @@ function registerUploadReleaseWalkthrough(server) {
     };
   });
 }
+function getPrototypeContentType(filename) {
+  const ext = filename.split(".").pop()?.toLowerCase() || "";
+  const types = {
+    html: "text/html",
+    css: "text/css",
+    js: "application/javascript",
+    json: "application/json",
+    png: "image/png",
+    jpg: "image/jpeg",
+    jpeg: "image/jpeg",
+    gif: "image/gif",
+    svg: "image/svg+xml",
+    webp: "image/webp"
+  };
+  return types[ext] || "application/octet-stream";
+}
+function registerPublishPrototype(server) {
+  server.registerTool("publish_prototype", {
+    description: "Publish a local prototype folder to a shareable URL. Uploads all files from the folder and returns a time-limited shareable link.",
+    inputSchema: {
+      roadmapId: z11.string().uuid().describe("The UUID of the roadmap item to attach the prototype to"),
+      folderPath: z11.string().describe("Absolute path to the local mockup folder"),
+      entryPoint: z11.string().default("index.html").describe("Main HTML file to open (defaults to index.html)")
+    }
+  }, async ({
+    roadmapId,
+    folderPath,
+    entryPoint
+  }) => {
+    const fs = await import("node:fs/promises");
+    const path = await import("node:path");
+    const client2 = getApiClient();
+    const ignoredNames = new Set([
+      ".DS_Store",
+      ".git",
+      "node_modules",
+      ".env",
+      ".gitignore",
+      ".npmrc",
+      "Thumbs.db",
+      ".idea",
+      ".vscode"
+    ]);
+    async function scanFolder(dir, base = "") {
+      const entries = await fs.readdir(dir, { withFileTypes: true });
+      const files2 = [];
+      for (const entry of entries) {
+        if (entry.name.startsWith(".") || ignoredNames.has(entry.name)) {
+          continue;
+        }
+        const relativePath = base ? `${base}/${entry.name}` : entry.name;
+        const fullPath = path.join(dir, entry.name);
+        if (entry.isDirectory()) {
+          files2.push(...await scanFolder(fullPath, relativePath));
+        } else {
+          files2.push(relativePath);
+        }
+      }
+      return files2;
+    }
+    try {
+      await fs.access(folderPath);
+    } catch {
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Error: Folder not found: ${folderPath}`
+          }
+        ]
+      };
+    }
+    const files = await scanFolder(folderPath);
+    if (files.length === 0) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Error: No files found in ${folderPath}`
+          }
+        ]
+      };
+    }
+    if (!files.includes(entryPoint)) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Error: Entry point "${entryPoint}" not found. Available files: ${files.slice(0, 10).join(", ")}${files.length > 10 ? "..." : ""}`
+          }
+        ]
+      };
+    }
+    const filesWithTypes = files.map((filename) => ({
+      filename,
+      contentType: getPrototypeContentType(filename)
+    }));
+    let uploadData;
+    try {
+      uploadData = await client2.getPrototypeUploadUrls(roadmapId, filesWithTypes);
+    } catch (error) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Error getting upload URLs: ${error instanceof Error ? error.message : String(error)}`
+          }
+        ]
+      };
+    }
+    const uploadUrlMap = new Map(uploadData.files.map((f) => [f.filename, f.uploadUrl]));
+    let uploaded = 0;
+    for (const file of files) {
+      const filePath = path.join(folderPath, file);
+      const fileContent = await fs.readFile(filePath);
+      const uploadUrl = uploadUrlMap.get(file);
+      if (!uploadUrl) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Error: No upload URL found for ${file}`
+            }
+          ]
+        };
+      }
+      try {
+        await client2.uploadFile(uploadUrl, fileContent, getPrototypeContentType(file));
+        uploaded++;
+      } catch (error) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Error uploading ${file}: ${error instanceof Error ? error.message : String(error)}`
+            }
+          ]
+        };
+      }
+    }
+    let prototype;
+    try {
+      prototype = await client2.createPrototype(roadmapId, {
+        token: uploadData.token,
+        fileCount: files.length,
+        entryPoint
+      });
+    } catch (error) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Error creating prototype record: ${error instanceof Error ? error.message : String(error)}`
+          }
+        ]
+      };
+    }
+    const expiryDate = new Date(prototype.expiresAt).toLocaleDateString("en-US", {
+      month: "long",
+      day: "numeric",
+      year: "numeric"
+    });
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Published ${uploaded} files!
+
+Share this link:
+${prototype.publicUrl}
+
+Expires: ${expiryDate}`
+        }
+      ]
+    };
+  });
+}
 
 // src/index.ts
 async function main() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ourroadmaps/mcp",
-  "version": "0.15.0",
+  "version": "0.17.0",
   "description": "MCP server for OurRoadmaps - manage roadmaps, features, and ideas from Claude Code",
   "type": "module",
   "bin": {