magicpod-mcp-server 0.1.7 → 0.1.8

package/build/index.js

@@ -5,6 +5,7 @@ import { searchMagicpodArticles } from "./tools/search-magicpod-articles.js";
 import { readMagicpodArticle } from "./tools/read-magicpod-article.js";
 import { initMagicPodApiProxy } from "./tools/magicpod-web-api.js";
 import { apiV1_0UploadFileCreate } from "./tools/api-v1-0-upload-file-create.js";
+import { apiV1_0UploadDataPatterns } from "./tools/api-v1-0-upload-data-patterns.js";
 const program = new Command();
 program.option("--api-token <key>", "MagicPod API token to use");
 program.option("--debug", "For internal debug use");
@@ -19,6 +20,7 @@ async function main() {
     const baseUrl = baseUrlEnvironmentVariable || "https://app.magicpod.com";
     const proxy = await initMagicPodApiProxy(baseUrl, options.apiToken, [
         apiV1_0UploadFileCreate(baseUrl, options.apiToken),
+        apiV1_0UploadDataPatterns(baseUrl, options.apiToken),
         searchMagicpodArticles(),
         readMagicpodArticle(),
     ]);

package/build/openapi-mcp-server/mcp/proxy.js

@@ -12,7 +12,7 @@ export class MCPProxy {
     openApiLookup;
     constructor(name, openApiSpec, apiToken, otherTools) {
         this.otherTools = otherTools;
-        this.server = new Server({ name, version: "0.1.7" }, { capabilities: { tools: {} } });
+        this.server = new Server({ name, version: "0.1.8" }, { capabilities: { tools: {} } });
         const baseUrl = openApiSpec.servers?.[0].url;
         if (!baseUrl) {
             throw new Error("No base URL found in OpenAPI spec");

package/build/tools/api-v1-0-upload-data-patterns.js

@@ -0,0 +1,284 @@
+import { z } from "zod";
+import fs from "fs";
+import path from "node:path";
+import axios from "axios";
+import FormData from "form-data";
+const checkBatchTaskStatus = async (baseUrl, apiToken, organizationName, projectName, batchTaskId) => {
+    const url = `${baseUrl}/api/v1.0/${organizationName}/${projectName}/batch-task/${batchTaskId}/`;
+    try {
+        const response = await axios.get(url, {
+            headers: {
+                Authorization: `Token ${apiToken}`,
+            },
+        });
+        if (response.status !== 200) {
+            throw new Error(`Failed to check batch task status: ${response.status}`);
+        }
+        return response.data;
+    }
+    catch (error) {
+        if (error.response) {
+            // HTTP error response from server
+            const status = error.response.status;
+            const errorData = error.response.data;
+            if (status === 401) {
+                throw new Error("Authentication failed while checking batch task status. Please check your API token.");
+            }
+            else if (status === 403) {
+                throw new Error("Access denied while checking batch task status.");
+            }
+            else if (status === 404) {
+                throw new Error(`Batch task ${batchTaskId} not found.`);
+            }
+            else if (status === 400) {
+                const errorMsg = typeof errorData === 'object' && errorData.detail
+                    ? errorData.detail
+                    : errorData;
+                throw new Error(`Invalid batch task request: ${errorMsg}`);
+            }
+            else {
+                throw new Error(`Failed to check batch task status: HTTP ${status} - ${errorData}`);
+            }
+        }
+        else {
+            // Network or other error
+            throw new Error(`Network error while checking batch task status: ${error.message || error}`);
+        }
+    }
+};
+const sleep = (ms) => {
+    return new Promise(resolve => setTimeout(resolve, ms));
+};
+const waitForBatchTaskCompletion = async (baseUrl, apiToken, organizationName, projectName, batchTaskId, timeoutMs = 5 * 60 * 1000, // 5 minutes default
+pollIntervalMs = 3000 // 3 seconds default
+) => {
+    const startTime = Date.now();
+    while (Date.now() - startTime < timeoutMs) {
+        try {
+            const taskResponse = await checkBatchTaskStatus(baseUrl, apiToken, organizationName, projectName, batchTaskId);
+            if (taskResponse.status === "succeeded") {
+                return {
+                    success: true,
+                    status: taskResponse.status,
+                    message: "Data pattern upload completed successfully"
+                };
+            }
+            else if (taskResponse.status === "failed") {
+                return {
+                    success: false,
+                    status: taskResponse.status,
+                    message: "Data pattern upload failed"
+                };
+            }
+            // Task is still in progress, wait before checking again
+            await sleep(pollIntervalMs);
+        }
+        catch (error) {
+            console.error("Error checking batch task status:", error);
+            // For critical errors (auth, not found, etc.), stop polling and return error
+            if (error instanceof Error &&
+                (error.message.includes('Authentication failed') ||
+                    error.message.includes('not found') ||
+                    error.message.includes('Access denied'))) {
+                return {
+                    success: false,
+                    status: "error",
+                    message: error.message
+                };
+            }
+            // For network errors, continue polling with backoff
+            await sleep(pollIntervalMs);
+        }
+    }
+    // Timeout reached
+    return {
+        success: false,
+        status: "timeout",
+        message: `Data pattern upload timed out after ${timeoutMs / 1000} seconds`
+    };
+};
+export const apiV1_0UploadDataPatterns = (baseUrl, apiToken) => {
+    return {
+        name: "API-v1_0_upload-data-patterns_create",
+        description: "Upload data pattern CSV to test case and wait for completion. This operation runs synchronously and will wait for the upload to finish before returning.",
+        inputSchema: z.object({
+            organizationName: z
+                .string()
+                .describe("The organization name"),
+            projectName: z.string().describe("The project name"),
+            testCaseNumber: z
+                .number()
+                .int()
+                .describe("The test case number"),
+            localFilePath: z
+                .string()
+                .describe("A local file path to upload CSV data pattern to MagicPod. Note that an absolute path is required. Its extension must be .csv"),
+            overwrite: z
+                .boolean()
+                .optional()
+                .default(false)
+                .describe("If true, overwrite the existing data pattern by the uploaded CSV file. If false, an error is raised if the data pattern already exists."),
+        }),
+        handleRequest: async ({ organizationName, projectName, testCaseNumber, localFilePath, overwrite = false }) => {
+            try {
+                if (!fs.existsSync(localFilePath)) {
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: JSON.stringify({
+                                    error: "No such file exists. Note that an absolute path is required",
+                                    status: "file_not_found",
+                                }),
+                            },
+                        ],
+                    };
+                }
+                const fileExtension = path.extname(localFilePath).toLowerCase();
+                if (fileExtension !== ".csv") {
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: JSON.stringify({
+                                    error: "Invalid file extension. The file must be a CSV file (.csv)",
+                                    status: "invalid_file_type",
+                                }),
+                            },
+                        ],
+                    };
+                }
+                const formData = new FormData();
+                const fileStream = fs.createReadStream(localFilePath);
+                const fileName = path.basename(localFilePath);
+                formData.append("file", fileStream, fileName);
+                formData.append("overwrite", overwrite.toString());
+                const url = `${baseUrl}/api/v1.0/${organizationName}/${projectName}/test-cases/${testCaseNumber}/start-upload-data-patterns/`;
+                let response;
+                try {
+                    response = await axios.post(url, formData, {
+                        headers: {
+                            ...formData.getHeaders(),
+                            Authorization: `Token ${apiToken}`,
+                        },
+                    });
+                }
+                catch (error) {
+                    if (error.response) {
+                        // HTTP error response from server
+                        const status = error.response.status;
+                        const errorData = error.response.data;
+                        let errorMessage = "An error occurred during upload";
+                        if (status === 400) {
+                            if (errorData && typeof errorData === 'object') {
+                                errorMessage = `Upload failed: ${JSON.stringify(errorData)}`;
+                            }
+                            else {
+                                errorMessage = `Upload failed with status ${status}: ${errorData}`;
+                            }
+                        }
+                        else if (status === 401) {
+                            errorMessage = "Authentication failed. Please check your API token.";
+                        }
+                        else if (status === 403) {
+                            errorMessage = "Access denied. You don't have permission to upload data patterns to this test case.";
+                        }
+                        else if (status === 404) {
+                            errorMessage = `Test case ${testCaseNumber} not found in project ${organizationName}/${projectName}.`;
+                        }
+                        else {
+                            errorMessage = `Upload failed with status ${status}: ${errorData}`;
+                        }
+                        return {
+                            content: [
+                                {
+                                    type: "text",
+                                    text: JSON.stringify({
+                                        error: errorMessage,
+                                        status: status,
+                                    }),
+                                },
+                            ],
+                        };
+                    }
+                    else {
+                        // Network or other error
+                        const errorMessage = error.message || "Network error during upload";
+                        return {
+                            content: [
+                                {
+                                    type: "text",
+                                    text: JSON.stringify({
+                                        error: errorMessage,
+                                        status: "network_error",
+                                    }),
+                                },
+                            ],
+                        };
+                    }
+                }
+                if (response.status !== 200) {
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: JSON.stringify({
+                                    error: "Unexpected response status from upload API",
+                                    status: response.status,
+                                }),
+                            },
+                        ],
+                    };
+                }
+                const batchTaskId = response.data.batch_task_id;
+                if (!batchTaskId) {
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: JSON.stringify({
+                                    error: "Upload started but no batch task ID was returned",
+                                    status: "invalid_response",
+                                }),
+                            },
+                        ],
+                    };
+                }
+                // Wait for the batch task to complete
+                const result = await waitForBatchTaskCompletion(baseUrl, apiToken, organizationName, projectName, batchTaskId);
+                if (result.success) {
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: JSON.stringify({
+                                    message: result.message,
+                                    batch_task_id: batchTaskId,
+                                    status: result.status,
+                                }),
+                            },
+                        ],
+                    };
+                }
+                else {
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: JSON.stringify({
+                                    error: result.message,
+                                    batch_task_id: batchTaskId,
+                                    status: result.status,
+                                }),
+                            },
+                        ],
+                    };
+                }
+            }
+            catch (error) {
+                console.error("Failed to upload the data pattern CSV file: ", error instanceof Error ? error.message : String(error));
+                throw error;
+            }
+        },
+    };
+};

package/build/tools/api-v1-0-upload-file-create.js

@@ -3,10 +3,106 @@ import fs from "fs";
 import path from "node:path";
 import axios from "axios";
 import FormData from "form-data";
+import { createReadStream } from "fs";
+import { Transform } from "stream";
+const ALLOWED_EXTENSIONS = ['.apk', '.aab', '.ipa', '.zip'];
+const isValidFileExtension = (filePath) => {
+    const ext = path.extname(filePath).toLowerCase();
+    return ALLOWED_EXTENSIONS.includes(ext);
+};
+const isValidZipWithApp = async (filePath) => {
+    if (path.extname(filePath).toLowerCase() !== '.zip') {
+        return true; // Not a zip file, skip this validation
+    }
+    return new Promise((resolve) => {
+        const fileStream = createReadStream(filePath);
+        let buffer = Buffer.alloc(0);
+        let hasAppDirectory = false;
+        let bytesRead = 0;
+        const MAX_BYTES_TO_READ = 10 * 1024 * 1024; // 10MB limit for safety
+        const LOCAL_FILE_HEADER_SIGNATURE = 0x04034b50;
+        const zipParser = new Transform({
+            transform(chunk, _encoding, callback) {
+                if (hasAppDirectory || bytesRead > MAX_BYTES_TO_READ) {
+                    callback();
+                    return;
+                }
+                bytesRead += chunk.length;
+                buffer = Buffer.concat([buffer, chunk]);
+                // Parse ZIP local file headers
+                let offset = 0;
+                while (offset < buffer.length - 30) { // Minimum header size is 30 bytes
+                    // Look for local file header signature
+                    const signature = buffer.readUInt32LE(offset);
+                    if (signature !== LOCAL_FILE_HEADER_SIGNATURE) {
+                        offset++;
+                        continue;
+                    }
+                    // Read filename length from header (at offset 26)
+                    if (offset + 30 > buffer.length)
+                        break;
+                    const filenameLength = buffer.readUInt16LE(offset + 26);
+                    const extraFieldLength = buffer.readUInt16LE(offset + 28);
+                    // Check if we have the complete entry
+                    if (offset + 30 + filenameLength > buffer.length) {
+                        break;
+                    }
+                    // Extract filename
+                    const filename = buffer.subarray(offset + 30, offset + 30 + filenameLength).toString('utf8');
+                    // Check if this is a .app directory (directories in ZIP end with /)
+                    if (filename.toLowerCase().endsWith('.app/')) {
+                        hasAppDirectory = true;
+                        callback();
+                        return;
+                    }
+                    // Move to next entry
+                    offset += 30 + filenameLength + extraFieldLength;
+                }
+                // Keep last 1KB of buffer for potential split headers
+                if (buffer.length > 1024) {
+                    buffer = buffer.subarray(buffer.length - 1024);
+                }
+                callback();
+            }
+        });
+        fileStream.pipe(zipParser);
+        fileStream.on('end', () => {
+            resolve(hasAppDirectory);
+        });
+        fileStream.on('error', () => {
+            resolve(false);
+        });
+        zipParser.on('error', () => {
+            resolve(false);
+        });
+    });
+};
+const validateFile = async (filePath) => {
+    if (!fs.existsSync(filePath)) {
+        return { valid: false, error: "No such file exists. Note that an absolute path is required" };
+    }
+    if (!isValidFileExtension(filePath)) {
+        return {
+            valid: false,
+            error: "Invalid file type. Only .apk, .aab, .ipa files, or zipped .app files are allowed"
+        };
+    }
+    const ext = path.extname(filePath).toLowerCase();
+    if (ext === '.zip') {
+        const hasValidApp = await isValidZipWithApp(filePath);
+        if (!hasValidApp) {
+            return {
+                valid: false,
+                error: "ZIP file must contain an .app directory to be valid"
+            };
+        }
+    }
+    return { valid: true };
+};
 export const apiV1_0UploadFileCreate = (baseUrl, apiToken) => {
     return {
         name: "API-v1_0_upload-file_create",
-        description: "Upload target app files (.app, .ipa, .apk or .aab) to MagicPod cloud",
+        description: "Upload target app files (.ipa, .apk, .aab, or zipped .app) to MagicPod cloud",
         inputSchema: z.object({
             organizationName: z
                 .string()
@@ -14,16 +110,17 @@ export const apiV1_0UploadFileCreate = (baseUrl, apiToken) => {
             projectName: z.string().describe("The project name to upload the file"),
             localFilePath: z
                 .string()
-                .describe("A local file path to upload to MagicPod. Note that an absolute path is required. Its extension must be .app, .ipa, .apk or .aab"),
+                .describe("A local file path to upload to MagicPod. Note that an absolute path is required. Supported formats: .ipa, .apk, .aab files, or .zip files containing .app directories"),
         }),
         handleRequest: async ({ organizationName, projectName, localFilePath }) => {
             try {
-                if (!fs.existsSync(localFilePath)) {
+                const validation = await validateFile(localFilePath);
+                if (!validation.valid) {
                     return {
                         content: [
                             {
                                 type: "text",
-                                text: "No such file exists. Note that an absolute path is required",
+                                text: validation.error,
                             },
                         ],
                     };

package/build/tools/magicpod-web-api.js

@@ -27,7 +27,8 @@ const unsupportedPaths = [
     '/v1.0/{organization_name}/{project_name}/screenshots/{batch_task_id}/',
     '/v1.0/magicpod-clients/api/{os}/{tag_or_version}/',
     '/v1.0/magicpod-clients/local/{os}/{version}/',
-    '/v1.0/{organization_name}/{project_name}/upload-file/'
+    '/v1.0/{organization_name}/{project_name}/upload-file/',
+    '/v1.0/{organization_name}/{project_name}/test-cases/{test_case_number}/start-upload-data-patterns/'
 ];
 export const initMagicPodApiProxy = async (baseUrl, apiToken, tools) => {
     const schemaUrl = `${baseUrl}/api/v1.0/doc/?format=openapi`;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "magicpod-mcp-server",
-  "version": "0.1.7",
+  "version": "0.1.8",
   "description": "Model Context Protocol server for MagicPod integration",
   "type": "module",
   "bin": {