@ourroadmaps/mcp 0.10.0 → 0.12.0

package/dist/index.js

@@ -735,6 +735,91 @@ class ApiClient {
     });
     return response.data;
   }
+  async getWireframeUploadUrl(data) {
+    const response = await this.request("/v1/wireframes/upload-url", {
+      method: "POST",
+      body: JSON.stringify(data)
+    });
+    return response.data;
+  }
+  async createWireframe(roadmapId, data) {
+    const response = await this.request(`/v1/wireframes/roadmaps/${roadmapId}/wireframes`, {
+      method: "POST",
+      body: JSON.stringify(data)
+    });
+    return response.data;
+  }
+  async updateWireframe(id, data) {
+    const response = await this.request(`/v1/wireframes/${id}`, {
+      method: "PATCH",
+      body: JSON.stringify(data)
+    });
+    return response.data;
+  }
+  async updateWireframeOutcomes(id, outcomeIds) {
+    const response = await this.request(`/v1/wireframes/${id}/outcomes`, {
+      method: "POST",
+      body: JSON.stringify({ outcomeIds })
+    });
+    return response.data;
+  }
+  async deleteWireframe(id) {
+    await this.request(`/v1/wireframes/${id}`, {
+      method: "DELETE"
+    });
+  }
+  async getBrainstormUploadUrl(data) {
+    const response = await this.request("/v1/brainstorm/upload-url", {
+      method: "POST",
+      body: JSON.stringify(data)
+    });
+    return response.data;
+  }
+  async createBrainstormMedia(roadmapId, data) {
+    const response = await this.request(`/v1/brainstorm/roadmaps/${roadmapId}/media`, {
+      method: "POST",
+      body: JSON.stringify(data)
+    });
+    return response.data;
+  }
+  async updateBrainstormMedia(id, data) {
+    const response = await this.request(`/v1/brainstorm/media/${id}`, {
+      method: "PATCH",
+      body: JSON.stringify(data)
+    });
+    return response.data;
+  }
+  async deleteBrainstormMedia(id) {
+    await this.request(`/v1/brainstorm/media/${id}`, {
+      method: "DELETE"
+    });
+  }
+  async getProductDesignUploadUrl(productId, data) {
+    const response = await this.request(`/v1/products/${productId}/design-media/upload-url`, {
+      method: "POST",
+      body: JSON.stringify(data)
+    });
+    return response.data;
+  }
+  async createProductDesignMedia(productId, data) {
+    const response = await this.request(`/v1/products/${productId}/design-media`, {
+      method: "POST",
+      body: JSON.stringify(data)
+    });
+    return response.data;
+  }
+  async updateProductDesignMedia(productId, mediaId, data) {
+    const response = await this.request(`/v1/products/${productId}/design-media/${mediaId}`, {
+      method: "PATCH",
+      body: JSON.stringify(data)
+    });
+    return response.data;
+  }
+  async deleteProductDesignMedia(productId, mediaId) {
+    await this.request(`/v1/products/${productId}/design-media/${mediaId}`, {
+      method: "DELETE"
+    });
+  }
   async updateDesignDescription(roadmapId, description) {
     const response = await this.request(`/v1/designs/roadmaps/${roadmapId}/design`, {
       method: "PATCH",
@@ -773,6 +858,20 @@ function getApiClient() {
 }
 
 // src/tools/index.ts
+function inferContentType(filename) {
+  const ext = filename.split(".").pop()?.toLowerCase();
+  const mapping = {
+    png: "image/png",
+    jpg: "image/jpeg",
+    jpeg: "image/jpeg",
+    gif: "image/gif",
+    webp: "image/webp",
+    mp4: "video/mp4",
+    webm: "video/webm",
+    mov: "video/quicktime"
+  };
+  return ext ? mapping[ext] ?? null : null;
+}
 function registerAllTools(server) {
   registerSearchRoadmaps(server);
   registerGetRoadmap(server);
@@ -814,6 +913,15 @@ function registerAllTools(server) {
   registerGetHistorySummary(server);
   registerCreateStatusUpdate(server);
   registerSaveStories(server);
+  registerUploadWireframe(server);
+  registerUpdateWireframe(server);
+  registerDeleteWireframe(server);
+  registerUploadBrainstormMedia(server);
+  registerUpdateBrainstormMedia(server);
+  registerDeleteBrainstormMedia(server);
+  registerUploadProductDesignMedia(server);
+  registerUpdateProductDesignMedia(server);
+  registerDeleteProductDesignMedia(server);
 }
 function registerSearchRoadmaps(server) {
   server.registerTool("search_roadmaps", {
@@ -1211,7 +1319,7 @@ function registerUpdateRoadmapItem(server) {
       updates.effort = effort;
     if (order !== undefined)
       updates.order = order;
-    const roadmap2 = await client2.updateRoadmap(id, updates);
+    const roadmap2 = Object.keys(updates).length > 0 ? await client2.updateRoadmap(id, updates) : await client2.getRoadmap(id);
     const phaseUpdates = {};
     if (designDescription !== undefined) {
       await client2.updateDesignDescription(id, designDescription);
@@ -2260,6 +2368,323 @@ function registerSaveStories(server) {
     };
   });
 }
+function registerUploadWireframe(server) {
+  server.registerTool("upload_wireframe", {
+    description: "Upload an image to a roadmap item's wireframes. Returns a curl command to execute for the upload, then creates the wireframe record. After running the curl command, the wireframe will be visible in the web app.",
+    inputSchema: {
+      roadmapId: z10.string().describe("The UUID of the roadmap item"),
+      filePath: z10.string().describe("Absolute path to the image file on disk"),
+      description: z10.string().optional().describe("Optional description of the wireframe"),
+      outcomeIds: z10.array(z10.string()).optional().describe("Optional array of PRD outcome IDs this wireframe addresses")
+    }
+  }, async ({
+    roadmapId,
+    filePath,
+    description,
+    outcomeIds
+  }) => {
+    const client2 = getApiClient();
+    const filename = filePath.split("/").pop() || "image.png";
+    const contentType = inferContentType(filename);
+    if (!contentType || !contentType.startsWith("image/")) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify({
+              error: "Invalid file type. Wireframes only accept image files (png, jpeg, gif, webp)."
+            })
+          }
+        ]
+      };
+    }
+    const { uploadUrl, imageUrl } = await client2.getWireframeUploadUrl({
+      filename,
+      contentType
+    });
+    const wireframe = await client2.createWireframe(roadmapId, { imageUrl });
+    if (description) {
+      await client2.updateWireframe(wireframe.id, { description });
+    }
+    if (outcomeIds && outcomeIds.length > 0) {
+      await client2.updateWireframeOutcomes(wireframe.id, outcomeIds);
+    }
+    const curlCommand = `curl -X PUT -H "Content-Type: ${contentType}" --data-binary @"${filePath}" "${uploadUrl}"`;
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify({
+            wireframeId: wireframe.id,
+            imageUrl,
+            curlCommand,
+            instructions: "Execute the curlCommand to upload the file. The wireframe record has been created and will display the image once uploaded."
+          }, null, 2)
+        }
+      ]
+    };
+  });
+}
+function registerUpdateWireframe(server) {
+  server.registerTool("update_wireframe", {
+    description: "Update a wireframe's description or outcome tags.",
+    inputSchema: {
+      id: z10.string().describe("The UUID of the wireframe"),
+      description: z10.string().nullable().optional().describe("New description for the wireframe"),
+      outcomeIds: z10.array(z10.string()).optional().describe("Array of PRD outcome IDs this wireframe addresses (replaces existing)")
+    }
+  }, async ({
+    id,
+    description,
+    outcomeIds
+  }) => {
+    const client2 = getApiClient();
+    let wireframe;
+    if (description !== undefined) {
+      wireframe = await client2.updateWireframe(id, { description });
+    } else {
+      wireframe = await client2.updateWireframe(id, {});
+    }
+    if (outcomeIds !== undefined) {
+      wireframe = await client2.updateWireframeOutcomes(id, outcomeIds);
+    }
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify({
+            id: wireframe.id,
+            imageUrl: wireframe.imageUrl,
+            description: wireframe.description,
+            outcomes: wireframe.outcomes.map((o) => o.prdOutcomeId)
+          }, null, 2)
+        }
+      ]
+    };
+  });
+}
+function registerDeleteWireframe(server) {
+  server.registerTool("delete_wireframe", {
+    description: "Delete a wireframe (soft delete).",
+    inputSchema: {
+      id: z10.string().describe("The UUID of the wireframe to delete")
+    }
+  }, async ({ id }) => {
+    const client2 = getApiClient();
+    await client2.deleteWireframe(id);
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify({ success: true, deleted: id })
+        }
+      ]
+    };
+  });
+}
+function registerUploadBrainstormMedia(server) {
+  server.registerTool("upload_brainstorm_media", {
+    description: "Upload an image or video to a roadmap item's brainstorming section. Returns a curl command to execute for the upload.",
+    inputSchema: {
+      roadmapId: z10.string().describe("The UUID of the roadmap item"),
+      filePath: z10.string().describe("Absolute path to the image or video file on disk"),
+      description: z10.string().optional().describe("Optional description of the media")
+    }
+  }, async ({
+    roadmapId,
+    filePath,
+    description
+  }) => {
+    const client2 = getApiClient();
+    const filename = filePath.split("/").pop() || "file.bin";
+    const contentType = inferContentType(filename);
+    if (!contentType) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify({
+              error: "Invalid file type. Brainstorm media accepts images (png, jpeg, gif, webp) and videos (mp4, webm, mov)."
+            })
+          }
+        ]
+      };
+    }
+    const mediaType = contentType.startsWith("image/") ? "image" : "video";
+    const { uploadUrl, mediaUrl } = await client2.getBrainstormUploadUrl({
+      filename,
+      contentType
+    });
+    let media = await client2.createBrainstormMedia(roadmapId, { mediaUrl, mediaType });
+    if (description) {
+      media = await client2.updateBrainstormMedia(media.id, { description });
+    }
+    const curlCommand = `curl -X PUT -H "Content-Type: ${contentType}" --data-binary @"${filePath}" "${uploadUrl}"`;
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify({
+            mediaId: media.id,
+            mediaUrl,
+            mediaType,
+            curlCommand,
+            instructions: "Execute the curlCommand to upload the file. The media record has been created and will display once uploaded."
+          }, null, 2)
+        }
+      ]
+    };
+  });
+}
+function registerUpdateBrainstormMedia(server) {
+  server.registerTool("update_brainstorm_media", {
+    description: "Update a brainstorm media item's description.",
+    inputSchema: {
+      id: z10.string().describe("The UUID of the brainstorm media"),
+      description: z10.string().nullable().describe("New description for the media")
+    }
+  }, async ({ id, description }) => {
+    const client2 = getApiClient();
+    const media = await client2.updateBrainstormMedia(id, { description });
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify({
+            id: media.id,
+            mediaUrl: media.mediaUrl,
+            mediaType: media.mediaType,
+            description: media.description
+          }, null, 2)
+        }
+      ]
+    };
+  });
+}
+function registerDeleteBrainstormMedia(server) {
+  server.registerTool("delete_brainstorm_media", {
+    description: "Delete a brainstorm media item (soft delete).",
+    inputSchema: {
+      id: z10.string().describe("The UUID of the brainstorm media to delete")
+    }
+  }, async ({ id }) => {
+    const client2 = getApiClient();
+    await client2.deleteBrainstormMedia(id);
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify({ success: true, deleted: id })
+        }
+      ]
+    };
+  });
+}
+function registerUploadProductDesignMedia(server) {
+  server.registerTool("upload_product_design_media", {
+    description: "Upload an image or video to a product's design media section. Returns a curl command to execute for the upload.",
+    inputSchema: {
+      productId: z10.string().describe("The UUID of the product"),
+      filePath: z10.string().describe("Absolute path to the image or video file on disk"),
+      description: z10.string().optional().describe("Optional description of the media")
+    }
+  }, async ({
+    productId,
+    filePath,
+    description
+  }) => {
+    const client2 = getApiClient();
+    const filename = filePath.split("/").pop() || "file.bin";
+    const contentType = inferContentType(filename);
+    if (!contentType) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify({
+              error: "Invalid file type. Design media accepts images (png, jpeg, gif, webp) and videos (mp4, webm, mov)."
+            })
+          }
+        ]
+      };
+    }
+    const mediaType = contentType.startsWith("image/") ? "image" : "video";
+    const { uploadUrl, mediaUrl } = await client2.getProductDesignUploadUrl(productId, {
+      filename,
+      contentType
+    });
+    let media = await client2.createProductDesignMedia(productId, { mediaUrl, mediaType });
+    if (description) {
+      media = await client2.updateProductDesignMedia(productId, media.id, { description });
+    }
+    const curlCommand = `curl -X PUT -H "Content-Type: ${contentType}" --data-binary @"${filePath}" "${uploadUrl}"`;
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify({
+            mediaId: media.id,
+            productId,
+            mediaUrl,
+            mediaType,
+            curlCommand,
+            instructions: "Execute the curlCommand to upload the file. The media record has been created and will display once uploaded."
+          }, null, 2)
+        }
+      ]
+    };
+  });
+}
+function registerUpdateProductDesignMedia(server) {
+  server.registerTool("update_product_design_media", {
+    description: "Update a product design media item's description.",
+    inputSchema: {
+      productId: z10.string().describe("The UUID of the product"),
+      mediaId: z10.string().describe("The UUID of the design media"),
+      description: z10.string().nullable().describe("New description for the media")
+    }
+  }, async ({
+    productId,
+    mediaId,
+    description
+  }) => {
+    const client2 = getApiClient();
+    const media = await client2.updateProductDesignMedia(productId, mediaId, { description });
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify({
+            id: media.id,
+            mediaUrl: media.mediaUrl,
+            mediaType: media.mediaType,
+            description: media.description
+          }, null, 2)
+        }
+      ]
+    };
+  });
+}
+function registerDeleteProductDesignMedia(server) {
+  server.registerTool("delete_product_design_media", {
+    description: "Delete a product design media item (soft delete).",
+    inputSchema: {
+      productId: z10.string().describe("The UUID of the product"),
+      mediaId: z10.string().describe("The UUID of the design media to delete")
+    }
+  }, async ({ productId, mediaId }) => {
+    const client2 = getApiClient();
+    await client2.deleteProductDesignMedia(productId, mediaId);
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify({ success: true, deleted: mediaId })
+        }
+      ]
+    };
+  });
+}
 
 // src/index.ts
 async function main() {

package/package.json

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