wolfpack-mcp 1.0.19 → 1.0.21

package/dist/apiClient.js

@@ -96,6 +96,34 @@ export class ApiClient {
             throw new Error(`Failed to PATCH ${path}: ${error}`);
         }
     }
+    async postMultipart(path, buffer, filename, mimeType) {
+        const url = `${config.apiUrl}${path}`;
+        const boundary = `----FormBoundary${Date.now()}`;
+        const header = `--${boundary}\r\nContent-Disposition: form-data; name="file"; filename="${filename}"\r\nContent-Type: ${mimeType}\r\n\r\n`;
+        const footer = `\r\n--${boundary}--\r\n`;
+        const body = Buffer.concat([Buffer.from(header), buffer, Buffer.from(footer)]);
+        try {
+            const response = await fetch(url, {
+                method: 'POST',
+                headers: {
+                    Authorization: `Bearer ${config.apiKey}`,
+                    'Content-Type': `multipart/form-data; boundary=${boundary}`,
+                },
+                body,
+            });
+            if (!response.ok) {
+                const errorText = await response.text();
+                throw new ApiError(response.status, `API error: ${response.statusText} - ${errorText}`);
+            }
+            return (await response.json());
+        }
+        catch (error) {
+            if (error instanceof ApiError) {
+                throw error;
+            }
+            throw new Error(`Failed to POST multipart ${path}: ${error}`);
+        }
+    }
     async delete(path) {
         const url = `${config.apiUrl}${path}`;
         try {

package/dist/client.js

@@ -6,6 +6,7 @@ const PAGE_SIZE = 50;
 export class WolfpackClient {
     api;
     teamId = null;
+    teamSlug = null;
     constructor() {
         this.api = new ApiClient();
     }
@@ -17,6 +18,7 @@ export class WolfpackClient {
         try {
             const team = await this.api.get(`/team/${teamSlug}`);
             this.teamId = team.id;
+            this.teamSlug = team.slug;
             return team.id;
         }
         catch (error) {
@@ -26,9 +28,15 @@ export class WolfpackClient {
     getTeamId() {
         return this.teamId;
     }
+    getTeamSlug() {
+        return this.teamSlug;
+    }
     setTeamId(teamId) {
         this.teamId = teamId;
     }
+    setTeamSlug(slug) {
+        this.teamSlug = slug;
+    }
     /**
      * List all teams the authenticated user is a member of.
      */
@@ -375,6 +383,13 @@ export class WolfpackClient {
     async createIssueComment(issueId, data) {
         return this.api.post(`/issues/${issueId}/comments`, data);
     }
+    /**
+     * Upload an image and get back a URL that can be used in markdown content.
+     */
+    async uploadImage(teamSlug, base64Data, filename, mimeType) {
+        const buffer = Buffer.from(base64Data, 'base64');
+        return this.api.postMultipart(`/teams/${teamSlug}/upload-image`, buffer, filename, mimeType);
+    }
     close() {
         // No cleanup needed for API client
     }

package/dist/index.js

@@ -4,6 +4,8 @@ import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js'
 import { CallToolRequestSchema, ListToolsRequestSchema, } from '@modelcontextprotocol/sdk/types.js';
 import { z } from 'zod';
 import { createRequire } from 'module';
+import { readFile, stat } from 'fs/promises';
+import { resolve, basename, extname } from 'path';
 import { WolfpackClient } from './client.js';
 import { validateConfig, config } from './config.js';
 // Get current package version
@@ -240,6 +242,13 @@ const CreateIssueCommentSchema = z.object({
         .string()
         .describe('Comment content (markdown). Supports base64-encoded images which will be auto-uploaded.'),
 });
+// Image upload schema
+const UploadImageSchema = z.object({
+    file_path: z
+        .string()
+        .describe('Absolute path to an image file on disk (e.g., "/tmp/screenshot.png"). ' +
+        'Supported formats: JPEG, PNG, GIF, WebP. Max 5MB.'),
+});
 // Helper to detect if a work item description contains a plan
 function hasPlan(description) {
     if (!description)
@@ -783,6 +792,25 @@ class WolfpackMCPServer {
                         required: ['issue_id', 'content'],
                     },
                 },
+                // Image tools
+                {
+                    name: 'upload_image',
+                    description: 'Upload an image file from disk and get back a permanent URL. Much faster than embedding base64 in content. ' +
+                        'Pass the absolute file path - the file is read directly from disk without going through the LLM. ' +
+                        'Returns a markdown image URL you can include in any content field. ' +
+                        'Requires mcp:images:upload permission.',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            file_path: {
+                                type: 'string',
+                                description: 'Absolute path to an image file on disk (e.g., "/tmp/screenshot.png"). ' +
+                                    'Supported formats: JPEG, PNG, GIF, WebP. Max 5MB.',
+                            },
+                        },
+                        required: ['file_path'],
+                    },
+                },
             ],
         }));
         this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
@@ -1198,6 +1226,48 @@ class WolfpackMCPServer {
                             ],
                         };
                     }
+                    case 'upload_image': {
+                        const parsed = UploadImageSchema.parse(args);
+                        const teamSlug = this.client.getTeamSlug();
+                        if (!teamSlug) {
+                            throw new Error('No team selected. Use list_teams first.');
+                        }
+                        const filePath = resolve(parsed.file_path);
+                        // Validate file extension
+                        const ext = extname(filePath).toLowerCase();
+                        const allowedExtensions = {
+                            '.png': 'image/png',
+                            '.jpg': 'image/jpeg',
+                            '.jpeg': 'image/jpeg',
+                            '.gif': 'image/gif',
+                            '.webp': 'image/webp',
+                        };
+                        const mimeType = allowedExtensions[ext];
+                        if (!mimeType) {
+                            throw new Error(`Unsupported image format "${ext}". Supported: ${Object.keys(allowedExtensions).join(', ')}`);
+                        }
+                        // Check file exists and size
+                        const fileStat = await stat(filePath);
+                        const maxSize = 5 * 1024 * 1024; // 5MB
+                        if (fileStat.size > maxSize) {
+                            throw new Error(`File too large (${fileStat.size} bytes). Maximum size is 5MB.`);
+                        }
+                        // Validate magic bytes to confirm it's actually an image
+                        const buffer = await readFile(filePath);
+                        if (!this.isImageBuffer(buffer)) {
+                            throw new Error('File does not appear to be a valid image.');
+                        }
+                        const filename = basename(filePath);
+                        const result = await this.client.uploadImage(teamSlug, buffer.toString('base64'), filename, mimeType);
+                        return {
+                            content: [
+                                {
+                                    type: 'text',
+                                    text: `Image uploaded successfully.\n\nURL: ${result.url}\n\nUse this URL in markdown: ![${filename}](${result.url})`,
+                                },
+                            ],
+                        };
+                    }
                     default:
                         throw new Error(`Unknown tool: ${name}`);
                 }
@@ -1211,6 +1281,31 @@ class WolfpackMCPServer {
             }
         });
     }
+    isImageBuffer(buffer) {
+        if (buffer.length < 4)
+            return false;
+        // PNG: 89 50 4E 47
+        if (buffer[0] === 0x89 && buffer[1] === 0x50 && buffer[2] === 0x4e && buffer[3] === 0x47)
+            return true;
+        // JPEG: FF D8 FF
+        if (buffer[0] === 0xff && buffer[1] === 0xd8 && buffer[2] === 0xff)
+            return true;
+        // GIF: 47 49 46 38
+        if (buffer[0] === 0x47 && buffer[1] === 0x49 && buffer[2] === 0x46 && buffer[3] === 0x38)
+            return true;
+        // WebP: 52 49 46 46 ... 57 45 42 50
+        if (buffer.length >= 12 &&
+            buffer[0] === 0x52 &&
+            buffer[1] === 0x49 &&
+            buffer[2] === 0x46 &&
+            buffer[3] === 0x46 &&
+            buffer[8] === 0x57 &&
+            buffer[9] === 0x45 &&
+            buffer[10] === 0x42 &&
+            buffer[11] === 0x50)
+            return true;
+        return false;
+    }
     async start() {
         // Start version check early (non-blocking)
         const updateCheckPromise = checkForUpdates();
@@ -1233,6 +1328,7 @@ class WolfpackMCPServer {
                 if (teams.length === 1) {
                     // Auto-select the only team
                     this.client.setTeamId(teams[0].id);
+                    this.client.setTeamSlug(teams[0].slug);
                     console.error(`Auto-selected team: ${teams[0].name} (${teams[0].slug})`);
                 }
                 else if (teams.length === 0) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wolfpack-mcp",
-  "version": "1.0.19",
+  "version": "1.0.21",
   "description": "MCP server for Wolfpack AI-enhanced software delivery tools",
   "main": "dist/index.js",
   "type": "module",