wolfpack-mcp 1.0.19 → 1.0.20

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

@@ -240,6 +240,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({
+    image_data: z
+        .string()
+        .describe('Base64-encoded image data (without the data:image/...;base64, prefix)'),
+    filename: z.string().describe('Filename for the image (e.g., "screenshot.png")'),
+    mime_type: z
+        .string()
+        .optional()
+        .describe('MIME type of the image (e.g., "image/png"). If omitted, inferred from filename extension.'),
+});
 // Helper to detect if a work item description contains a plan
 function hasPlan(description) {
     if (!description)
@@ -783,6 +794,31 @@ class WolfpackMCPServer {
                         required: ['issue_id', 'content'],
                     },
                 },
+                // Image tools
+                {
+                    name: 'upload_image',
+                    description: 'Upload an image and get back a permanent URL. Use this instead of embedding base64 images in content - ' +
+                        'it is much faster and more efficient. Returns a markdown image URL you can include in any content field. ' +
+                        'Requires mcp:images:upload permission.',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            image_data: {
+                                type: 'string',
+                                description: 'Base64-encoded image data (without the data:image/...;base64, prefix). Just the raw base64 string.',
+                            },
+                            filename: {
+                                type: 'string',
+                                description: 'Filename for the image (e.g., "screenshot.png")',
+                            },
+                            mime_type: {
+                                type: 'string',
+                                description: 'MIME type of the image (e.g., "image/png"). If omitted, inferred from filename extension.',
+                            },
+                        },
+                        required: ['image_data', 'filename'],
+                    },
+                },
             ],
         }));
         this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
@@ -1198,6 +1234,23 @@ 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 mimeType = parsed.mime_type || this.inferMimeType(parsed.filename) || 'application/octet-stream';
+                        const result = await this.client.uploadImage(teamSlug, parsed.image_data, parsed.filename, mimeType);
+                        return {
+                            content: [
+                                {
+                                    type: 'text',
+                                    text: `Image uploaded successfully.\n\nURL: ${result.url}\n\nUse this URL in markdown: ![${parsed.filename}](${result.url})`,
+                                },
+                            ],
+                        };
+                    }
                     default:
                         throw new Error(`Unknown tool: ${name}`);
                 }
@@ -1211,6 +1264,18 @@ class WolfpackMCPServer {
             }
         });
     }
+    inferMimeType(filename) {
+        const ext = filename.split('.').pop()?.toLowerCase();
+        const mimeTypes = {
+            png: 'image/png',
+            jpg: 'image/jpeg',
+            jpeg: 'image/jpeg',
+            gif: 'image/gif',
+            webp: 'image/webp',
+            svg: 'image/svg+xml',
+        };
+        return ext ? mimeTypes[ext] || null : null;
+    }
     async start() {
         // Start version check early (non-blocking)
         const updateCheckPromise = checkForUpdates();
@@ -1233,6 +1298,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.20",
   "description": "MCP server for Wolfpack AI-enhanced software delivery tools",
   "main": "dist/index.js",
   "type": "module",