wolfpack-mcp 1.0.24 → 1.0.25

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

@@ -29,6 +29,19 @@ export class WolfpackClient {
     setTeamId(teamId) {
         this.teamId = teamId;
     }
+    /**
+     * Resolve a team slug from a team ID or the cached team ID.
+     */
+    async resolveSlug(teamId) {
+        const id = teamId || this.teamId;
+        if (!id)
+            throw new Error('No team selected. Use list_teams first.');
+        const teams = await this.listTeams();
+        const team = teams.find((t) => t.id === id);
+        if (!team)
+            throw new Error(`Team with ID ${id} not found`);
+        return team.slug;
+    }
     /**
      * List all teams the authenticated user is a member of.
      */
@@ -379,6 +392,10 @@ export class WolfpackClient {
     /**
      * 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 { basename, extname, resolve } from 'path';
 import { WolfpackClient } from './client.js';
 import { validateConfig, config } from './config.js';
 // Get current package version
@@ -240,6 +242,17 @@ 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.'),
+    team_id: z
+        .number()
+        .optional()
+        .describe('Team ID (required for multi-team users, use list_teams to get IDs)'),
+});
 // Helper to detect if a work item description contains a plan
 function hasPlan(description) {
     if (!description)
@@ -783,6 +796,29 @@ class WolfpackMCPServer {
                         required: ['issue_id', 'content'],
                     },
                 },
+                // Image tools
+                {
+                    name: 'upload_image',
+                    description: 'Upload an image file from disk and get back a permanent URL. ' +
+                        'Reads the file directly from disk, avoiding slow base64 token generation. ' +
+                        '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.',
+                            },
+                            team_id: {
+                                type: 'number',
+                                description: 'Team ID (required for multi-team users, use list_teams to get IDs)',
+                            },
+                        },
+                        required: ['file_path'],
+                    },
+                },
             ],
         }));
         this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
@@ -1198,6 +1234,45 @@ class WolfpackMCPServer {
                             ],
                         };
                     }
+                    case 'upload_image': {
+                        const parsed = UploadImageSchema.parse(args);
+                        const teamSlug = await this.client.resolveSlug(parsed.team_id || this.client.getTeamId() || undefined);
+                        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 +1286,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();

package/package.json

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