kickload-watcher-mcp 0.1.4 → 0.1.6

package/kickload-client.js

@@ -16,7 +16,7 @@ import fs       from "fs";
 import path     from "path";
 
 const POLL_INTERVAL_MS = 5000;    // 5s between polls — matches backend
-const POLL_TIMEOUT_MS = 1800000; // 30 min
+const POLL_TIMEOUT_MS  = 600000;  // 10 minutes max
 
 export class KickloadClient {
   /**
@@ -59,16 +59,20 @@ export class KickloadClient {
     }
 
     if (!response.ok) {
-      const err    = new Error(
-        `Kickload ${method} ${endpoint} → ${response.status} ${response.statusText}\n` +
-        `URL: ${url}\n` +
-        `Response: ${text.substring(0, 500)}`
-      );
-      err.status   = response.status;
-      err.body     = text;
-      err.parsed   = parsed;
-      throw err;
-    }
+  if (response.status === 401 || response.status === 403) {
+    throw new Error(
+      "Kickload authentication failed — check your API token or subscription"
+    );
+  }
+
+  if (response.status === 504) {
+    throw new Error("Kickload server timeout (504)");
+  }
+
+  throw new Error(
+    `Kickload ${method} ${endpoint} → ${response.status} ${response.statusText}`
+  );
+}
 
     return parsed;
   }
@@ -82,19 +86,34 @@ export class KickloadClient {
   // Returns: { status: "success", jmx_filename: "test_plan_xxx.jmx" }
   // ══════════════════════════════════════════════════════════════
   async generateTestPlan({ prompt, jmxFilePath } = {}) {
-  if (!prompt && !jmxFilePath) {
-    throw new Error("generateTestPlan: provide at least a prompt or jmxFilePath");
-  }
+    if (!prompt && !jmxFilePath) {
+      throw new Error("generateTestPlan: provide at least a prompt or jmxFilePath");
+    }
+
+    const form = new FormData();
+
+    if (prompt) {
+      form.append("prompt", prompt);
+    }
+
+    if (jmxFilePath) {
+      const resolved = path.resolve(jmxFilePath);
+      if (!fs.existsSync(resolved)) {
+        throw new Error(`JMX file not found: ${resolved}`);
+      }
+      form.append("file", fs.createReadStream(resolved), {
+        filename:    path.basename(resolved),
+        contentType: "application/xml",
+      });
+    }
 
-  console.log("\n📋 STEP 1: Generating test plan...");
-  if (prompt) console.log(`   Prompt  : ${prompt.substring(0, 100)}`);
-  if (jmxFilePath) console.log(`   JMX file: ${jmxFilePath}`);
+    console.log("\n📋 STEP 1: Generating test plan...");
+    if (prompt)      console.log(`   Prompt  : ${prompt.substring(0, 100)}`);
+    if (jmxFilePath) console.log(`   JMX file: ${jmxFilePath}`);
 
-  // ✅ FIX: send JSON when only prompt is provided
-  if (prompt && !jmxFilePath) {
     const result = await this._fetch("POST", "/generate-test-plan", {
-      body: JSON.stringify({ prompt }),
-      isJson: true,
+      body:    form,
+      headers: form.getHeaders(),
     });
 
     if (result.status !== "success") {
@@ -107,38 +126,6 @@ export class KickloadClient {
     return result;
   }
 
-  // ✅ fallback: use FormData only if file is present
-  const form = new FormData();
-
-  if (prompt) {
-    form.append("prompt", prompt);
-  }
-
-  if (jmxFilePath) {
-    const resolved = path.resolve(jmxFilePath);
-    if (!fs.existsSync(resolved)) {
-      throw new Error(`JMX file not found: ${resolved}`);
-    }
-    form.append("file", fs.createReadStream(resolved), {
-      filename: path.basename(resolved),
-      contentType: "application/xml",
-    });
-  }
-
-  const result = await this._fetch("POST", "/generate-test-plan", {
-    body: form,
-    headers: form.getHeaders(),
-  });
-
-  if (result.status !== "success") {
-    throw new Error(
-      `Test plan generation failed: ${result.message || JSON.stringify(result)}`
-    );
-  }
-
-  console.log(`✅ STEP 1 done — JMX: ${result.jmx_filename}`);
-  return result;
-}
   // ══════════════════════════════════════════════════════════════
   // STEP 2 — Run Test
   // POST /run-test/{jmx_filename}
@@ -214,13 +201,7 @@ export class KickloadClient {
       throw new Error(`Task ${taskId} unknown status: ${result.status}`);
     }
 
-    throw new Error(
-      `Task ${taskId} timed out after ${POLL_TIMEOUT_MS / 60000} minutes.\n` +
-      `Possible reasons:\n` +
-      `- Large load test\n` +
-      `- Slow backend\n` +
-      `- KickLoad server delay`
-    );
+    throw new Error(`Task ${taskId} timed out after ${POLL_TIMEOUT_MS / 60000} minutes`);
   }
 
   // ══════════════════════════════════════════════════════════════

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kickload-watcher-mcp",
-  "version": "0.1.4",
+  "version": "0.1.6",
   "description": "Automated API performance testing for Claude Code teams via KickLoad",
   "main": "index.js",
   "type": "module",

package/pipeline.js

@@ -226,85 +226,11 @@ export async function runPhase1Pipeline(event) {
     const client = new KickloadClient(config.kickload.baseUrl, config.kickload.apiToken);
 
     logger.step("Generating test plan");
+    const { jmx_filename: jmxFilename } = await withRetry(
+      () => client.generateTestPlan({ prompt: testParams.testPrompt, jmxFilePath: jmxFilePath || null }),
+      "generate-test-plan"
+    );
 
-    let jmxFilename = null;
-    let kickloadFailed = false;
-    let kickloadErrorMsg = "";
-
-      for (let attempt = 1; attempt <= 3; attempt++) {
-        try {
-          const res = await client.generateTestPlan({
-            prompt: testParams.testPrompt,
-            jmxFilePath: jmxFilePath || null
-          });
-
-           jmxFilename = res.jmx_filename;
-           break;
-
-        } catch (err) {
-          kickloadErrorMsg = err.message || "unknown error";
-
-          const status =
-            err.status ||
-            err.response?.status ||
-            (err.message?.includes("500") ? 500 : 0);
-
-    // retry only for 503 / 5xx
-    if (status >= 500 && attempt < 3) {
-      logger.warn(`Kickload attempt ${attempt}/3 failed — retrying in 3s (${kickloadErrorMsg})`);
-      await sleep(3000);
-    } else {
-      kickloadFailed = true;
-      logger.error(`Kickload failed after retries: ${kickloadErrorMsg}`);
-      break;
-    }
-  }
-}
-if (kickloadFailed || !jmxFilename) {
-  logger.warn("⚠️ Kickload failed — continuing with fallback result");
-  logger.info(`Fallback reason: ${kickloadErrorMsg}`);
-
-// fake result so pipeline completes fully
-const totalMs = Date.now() - start;
-
-const summary = {
-  passed: false,
-  averageLatency: null,
-  errorPercentage: 100,
-  throughput: null,
-  note: "Test plan generation failed — fallback result generated"
-};
-
-logPipelineSummary({
-  endpoint: endpoints.join(", "),
-  passed: summary.passed,
-  latency: summary.averageLatency,
-  errorRate: summary.errorPercentage,
-  throughput: summary.throughput,
-  durationSec: Math.round(totalMs / 1000),
-  emailSent: !!devEmail,
-  devEmail,
-});
-
-// send email
-if (devEmail) {
-  await safeResultEmail({
-    toEmail: devEmail,
-    endpoint: endpoints.join(", "),
-    passed: false,
-    summary,
-    downloadUrl: null,
-    pdfFilename: null,
-    durationMs: totalMs,
-    testPrompt: testParams.testPrompt,
-  });
-}
-
-return {
-  success: true,   // 👈 IMPORTANT: pipeline completed
-  fallback: true
-};
-}
     logger.step("Running test");
     const { task_id: taskId } = await withRetry(
       () => client.runTest(jmxFilename, { numThreads: testParams.numThreads, loopCount: testParams.loopCount, rampTime: testParams.rampTime }),
@@ -352,7 +278,19 @@ return {
     return { success: true, backendUrl, jmxFilename, taskId, jtlFilename: taskResult.result_file, pdfFilename, downloadUrl, summary };
 
   } catch (err) {
-    logger.error(`Pipeline failed: ${err.message}`);
+    if (err.message.includes("504") || err.message.includes("Gateway")) {
+  logger.error("❌ Kickload server is currently unavailable (504 timeout)");
+  logger.error("   This is a server-side issue, not your API");
+  logger.error("   Try again after some time\n");
+} else if (err.message.includes("401") || err.message.includes("403")) {
+  logger.error("❌ Kickload authentication failed");
+  logger.error("   Possible reasons:");
+  logger.error("   • Invalid API token");
+  logger.error("   • Token expired");
+  logger.error("   • Subscription required\n");
+} else {
+  logger.error(`Pipeline failed: ${err.message}`);
+}
 
     if (devEmail) {
       await safeResultEmail({
@@ -488,10 +426,7 @@ async function withRetry(fn, label) {
       return await fn();
     } catch (err) {
       lastErr = err;
-      const status =
-        err.status ||
-        err.response?.status ||
-        (err.message?.includes("500") ? 500 : 0);
+      const status = err.status || 0;
       if (status >= 400 && status < 500 && status !== 429) throw err;
       if (attempt <= MAX_RETRIES) {
         logger.warn(`[${label}] attempt ${attempt} failed — retrying in ${RETRY_DELAY_MS / 1000}s (${err.message})`);