kickload-watcher-mcp 0.1.0

package/kickload-client.js

@@ -0,0 +1,254 @@
+// kickload-client.js
+// Single source of truth for ALL Kickload API calls.
+// Every endpoint verified against app.py source code.
+//
+// ⚠️  NEW BASE URL: https://kickload.neeyatai.com/api
+// All routes are relative to this base, e.g.:
+//   POST https://kickload.neeyatai.com/api/generate-test-plan
+//   POST https://kickload.neeyatai.com/api/run-test/{filename}
+//   GET  https://kickload.neeyatai.com/api/task-status/{id}
+//   POST https://kickload.neeyatai.com/api/analyzeJTL
+//   GET  https://kickload.neeyatai.com/api/download/{filename}
+
+import FormData from "form-data";
+import fetch    from "node-fetch";
+import fs       from "fs";
+import path     from "path";
+
+const POLL_INTERVAL_MS = 5000;    // 5s between polls — matches backend
+const POLL_TIMEOUT_MS  = 600000;  // 10 minutes max
+
+export class KickloadClient {
+  /**
+   * @param {string} baseUrl  — e.g. "https://kickload.neeyatai.com/api"
+   * @param {string} apiToken — X-API-Token value
+   */
+  constructor(baseUrl, apiToken) {
+    // Normalize: strip trailing slash
+    this.baseUrl = baseUrl.replace(/\/$/, "");
+    this.token   = apiToken;
+  }
+
+  // ─── Private authenticated fetch ─────────────────────────────
+  async _fetch(method, endpoint, { body, headers = {}, isJson = false } = {}) {
+    const url = `${this.baseUrl}${endpoint}`;
+
+    const reqHeaders = {
+      "X-API-Token": this.token,
+      ...headers,
+    };
+
+    if (isJson) {
+      reqHeaders["Content-Type"] = "application/json";
+    }
+
+    const response = await fetch(url, {
+      method,
+      headers: reqHeaders,
+      body,
+      signal: AbortSignal.timeout(POLL_TIMEOUT_MS),
+    });
+
+    const text = await response.text();
+
+    let parsed;
+    try {
+      parsed = JSON.parse(text);
+    } catch {
+      parsed = { _raw: text };
+    }
+
+    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;
+    }
+
+    return parsed;
+  }
+
+  // ══════════════════════════════════════════════════════════════
+  // STEP 1 — Generate Test Plan
+  // POST /generate-test-plan
+  // Source: app.py line 1260
+  //
+  // Send prompt OR JMX file OR both.
+  // 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");
+    }
+
+    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}`);
+
+    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}
+  // Source: app.py line 1022
+  //
+  // Returns: { status: "started", task_id: "uuid-xxxx" }
+  // ══════════════════════════════════════════════════════════════
+  async runTest(jmxFilename, { numThreads, loopCount, rampTime } = {}) {
+    if (!jmxFilename) {
+      throw new Error("runTest: jmxFilename is required");
+    }
+
+    const body = {};
+    if (numThreads !== undefined) body.num_threads = numThreads;
+    if (loopCount  !== undefined) body.loop_count  = loopCount;
+    if (rampTime   !== undefined) body.ramp_time   = rampTime;
+
+    console.log(`\n▶️  STEP 2: Running test — ${jmxFilename}`);
+    console.log(`   Overrides: ${JSON.stringify(body) || "none (using JMX defaults)"}`);
+
+    const result = await this._fetch(
+      "POST",
+      `/run-test/${encodeURIComponent(jmxFilename)}`,
+      { body: JSON.stringify(body), isJson: true }
+    );
+
+    if (result.status !== "started") {
+      throw new Error(`Run test failed: ${result.message || JSON.stringify(result)}`);
+    }
+
+    console.log(`✅ STEP 2 done — Task ID: ${result.task_id}`);
+    return result;
+  }
+
+  // ══════════════════════════════════════════════════════════════
+  // STEP 3 — Poll Task Status
+  // GET /task-status/{task_id}
+  // Source: app.py line 899
+  //
+  // Polls every 5s until status = "success" | "error"
+  // Returns: { status, result_file, pdf_file, summary_output }
+  // ══════════════════════════════════════════════════════════════
+  async pollUntilDone(taskId) {
+    if (!taskId) throw new Error("pollUntilDone: taskId is required");
+
+    console.log(`\n⏳ STEP 3: Polling task ${taskId}`);
+    const started = Date.now();
+    let   polls   = 0;
+
+    while (Date.now() - started < POLL_TIMEOUT_MS) {
+      await sleep(POLL_INTERVAL_MS);
+      polls++;
+
+      const result  = await this._fetch("GET", `/task-status/${taskId}`);
+      const elapsed = Math.round((Date.now() - started) / 1000);
+
+      if (result.status === "running") {
+        process.stdout.write(`\r   ⏳ Running... ${elapsed}s (poll #${polls})`);
+        continue;
+      }
+
+      if (result.status === "success") {
+        console.log(`\n✅ STEP 3 done in ${elapsed}s`);
+        console.log(`   JTL: ${result.result_file}`);
+        console.log(`   PDF: ${result.pdf_file}`);
+        return result;
+      }
+
+      if (result.status === "error") {
+        throw new Error(`Task ${taskId} failed: ${result.message}`);
+      }
+
+      throw new Error(`Task ${taskId} unknown status: ${result.status}`);
+    }
+
+    throw new Error(`Task ${taskId} timed out after ${POLL_TIMEOUT_MS / 60000} minutes`);
+  }
+
+  // ══════════════════════════════════════════════════════════════
+  // STEP 4 — Analyze JTL
+  // POST /analyzeJTL
+  // Source: app.py line 1127
+  //
+  // Returns: { filename: "analysis_xxx.pdf" }
+  // ══════════════════════════════════════════════════════════════
+  async analyzeJtl(jtlFilename) {
+    if (!jtlFilename) throw new Error("analyzeJtl: jtlFilename is required");
+
+    console.log(`\n🔬 STEP 4: Analyzing JTL — ${jtlFilename}`);
+
+    const result = await this._fetch("POST", "/analyzeJTL", {
+      body:   JSON.stringify({ filename: jtlFilename }),
+      isJson: true,
+    });
+
+    if (!result.filename) {
+      throw new Error(`JTL analysis returned no filename: ${JSON.stringify(result)}`);
+    }
+
+    console.log(`✅ STEP 4 done — Analysis PDF: ${result.filename}`);
+    return result;
+  }
+
+  // ══════════════════════════════════════════════════════════════
+  // STEP 5 — Get Download URL
+  // GET /download/{filename}?mode=inline
+  // Source: app.py line 1472
+  //
+  // Returns: { status: "success", download_url: "https://s3.amazonaws.com/..." }
+  // ══════════════════════════════════════════════════════════════
+  async getDownloadUrl(filename) {
+    if (!filename) return null;
+
+    try {
+      const result = await this._fetch(
+        "GET",
+        `/download/${encodeURIComponent(filename)}?mode=inline`
+      );
+      return result.download_url || null;
+    } catch (err) {
+      console.warn(`⚠️  Download URL failed for ${filename}: ${err.message}`);
+      return null;
+    }
+  }
+}
+
+// ─── Utility ──────────────────────────────────────────────────
+function sleep(ms) {
+  return new Promise(resolve => setTimeout(resolve, ms));
+}

package/logger.js

@@ -0,0 +1,118 @@
+// logger.js — Consistent logging across all KickLoad Watcher modules
+// Color-coded, timestamped, and level-filtered.
+
+import { config } from "./config.js";
+
+const LEVELS = { debug: 0, info: 1, warn: 2, error: 3 };
+const currentLevel = LEVELS[config.logLevel] ?? LEVELS.info;
+
+// ANSI color codes
+const colors = {
+  reset:  "\x1b[0m",
+  dim:    "\x1b[2m",
+  red:    "\x1b[31m",
+  yellow: "\x1b[33m",
+  green:  "\x1b[32m",
+  blue:   "\x1b[34m",
+  cyan:   "\x1b[36m",
+  white:  "\x1b[37m",
+  orange: "\x1b[38;5;214m",
+};
+
+const levelConfig = {
+  debug: { color: colors.dim,    icon: "⬜", label: "DEBUG" },
+  info:  { color: colors.cyan,   icon: "🔵", label: "INFO " },
+  warn:  { color: colors.yellow, icon: "🟡", label: "WARN " },
+  error: { color: colors.red,    icon: "🔴", label: "ERROR" },
+};
+
+function timestamp() {
+  return new Date().toLocaleTimeString("en-IN", {
+    timeZone: "Asia/Kolkata",
+    hour12: false,
+    hour: "2-digit",
+    minute: "2-digit",
+    second: "2-digit",
+  });
+}
+
+function log(level, module, message, data) {
+  if (LEVELS[level] < currentLevel) return;
+
+  const lc = levelConfig[level];
+  const ts = `${colors.dim}${timestamp()}${colors.reset}`;
+  const mod = module
+    ? `${colors.orange}[${module}]${colors.reset}`
+    : "";
+  const lvl = `${lc.color}${lc.label}${colors.reset}`;
+  const msg = `${lc.color}${message}${colors.reset}`;
+
+  const line = `${ts} ${lc.icon} ${lvl} ${mod} ${msg}`;
+  console.log(line);
+
+  if (data !== undefined) {
+    console.log(
+      `${colors.dim}${JSON.stringify(data, null, 2)}${colors.reset}`
+    );
+  }
+}
+
+/**
+ * Create a module-specific logger.
+ * Usage: const logger = createLogger("kickload-runner");
+ *        logger.info("Test started", { endpoint });
+ */
+export function createLogger(module) {
+  return {
+    debug: (msg, data) => log("debug", module, msg, data),
+    info:  (msg, data) => log("info",  module, msg, data),
+    warn:  (msg, data) => log("warn",  module, msg, data),
+    error: (msg, data) => log("error", module, msg, data),
+
+    // Structured event logging
+    event: (eventName, data) => {
+      log("info", module, `EVENT: ${eventName}`, data);
+    },
+
+    // Pipeline step logging
+    step: (stepName, detail) => {
+      log("info", module, `  ▶ ${stepName}${detail ? `: ${detail}` : ""}`);
+    },
+
+    // Success/failure
+    success: (msg, data) => log("info",  module, `✅ ${msg}`, data),
+    failure: (msg, data) => log("error", module, `❌ ${msg}`, data),
+  };
+}
+
+// Global logger (no module prefix)
+export const logger = createLogger(null);
+
+/**
+ * Log a full pipeline run summary.
+ */
+export function logPipelineSummary({
+  endpoint,
+  passed,
+  latency,
+  errorRate,
+  throughput,
+  durationSec,
+  emailSent,
+  devEmail,
+}) {
+  const status = passed ? `${colors.green}✅ PASS${colors.reset}` : `${colors.red}❌ FAIL${colors.reset}`;
+  const separator = `${colors.dim}${"─".repeat(55)}${colors.reset}`;
+
+  console.log(`\n${separator}`);
+  console.log(`  ${colors.orange}KICKLOAD WATCHER — PIPELINE COMPLETE${colors.reset}`);
+  console.log(separator);
+  console.log(`  Endpoint:   ${colors.cyan}${endpoint}${colors.reset}`);
+  console.log(`  Result:     ${status}`);
+  if (latency != null)    console.log(`  Latency:    ${latency}ms`);
+  if (errorRate != null)  console.log(`  Error Rate: ${errorRate}%`);
+  if (throughput != null) console.log(`  Throughput: ${throughput.toLocaleString()} req/s`);
+  if (durationSec != null) console.log(`  Duration:   ${durationSec}s`);
+  console.log(`  Email:      ${emailSent ? `${colors.green}Sent${colors.reset} → ${devEmail}` : `${colors.dim}Skipped${colors.reset}`}`);
+  console.log(`${separator}\n`);
+}

package/ngrok-manager.js

@@ -0,0 +1,313 @@
+import { spawn }             from "child_process";
+import fs                    from "fs";
+import fsp                   from "fs/promises";
+import path                  from "path";
+import os                    from "os";
+import https                 from "https";
+import { createWriteStream } from "fs";
+import fetch                 from "node-fetch";
+import { createLogger }      from "./logger.js";
+import { config }            from "./config.js";
+
+const logger = createLogger("ngrok");
+
+const NGROK_API_URL    = "http://localhost:4040/api/tunnels";
+const STARTUP_MS       = 20_000;  // slightly more generous
+const FETCH_TIMEOUT_MS = 4_000;
+const POLL_INTERVAL_MS = 500;
+
+// ngrok 3 stable — equinox CDN pattern
+const NGROK_CDN = "https://bin.equinox.io/c/bNyj1mQVY4c";
+
+let activeProcess = null;
+let activeUrl     = null;
+let startPromise  = null;
+
+// ── Public ────────────────────────────────────────────────────────────────────
+
+/**
+ * Get or create a public ngrok URL for a local URL.
+ * PROBLEM 1: Called automatically for any localhost backend.
+ * PROBLEM 5: Caller (pipeline.js) retries this up to NGROK_MAX_RETRIES times.
+ */
+export async function getPublicUrl(localUrl) {
+  await ensureNgrokInstalled();
+
+  const port = extractPort(localUrl);
+  if (!port) throw new Error(`Cannot extract port from URL: ${localUrl}`);
+
+  // Check for an already-running tunnel
+  const existing = await fetchExistingTunnel(port);
+  if (existing) {
+    logger.info(`Reusing existing tunnel: ${existing}`);
+    activeUrl = existing;
+    return existing;
+  }
+
+  // De-duplicate concurrent start requests
+  if (startPromise) return startPromise;
+
+  startPromise = startTunnel(port).finally(() => { startPromise = null; });
+  return startPromise;
+}
+
+export function stopNgrok() {
+  if (!activeProcess) return;
+  try {
+    activeProcess.kill("SIGTERM");
+  } catch { /* ignore */ }
+  activeProcess = null;
+  activeUrl     = null;
+  logger.info("ngrok stopped.");
+}
+
+export function getActiveUrl() { return activeUrl; }
+
+// ── Binary management ─────────────────────────────────────────────────────────
+
+export async function ensureNgrokInstalled() {
+  const bin = getBinPath();
+  if (binExists(bin)) return;
+
+  const dir = path.dirname(bin);
+  await fsp.mkdir(dir, { recursive: true });
+
+  const { url, isZip } = getDownloadUrl();
+  const ext            = isZip ? "zip" : "tgz";
+  const archive        = path.join(dir, `ngrok-download.${ext}`);
+
+  logger.info(`Downloading ngrok binary...`);
+  logger.info(`  Platform : ${process.platform}/${os.arch()}`);
+  logger.info(`  Source   : ${url}`);
+
+  try {
+    await downloadFile(url, archive);
+  } catch (err) {
+    await fsp.rm(archive, { force: true });
+    throw new Error(`ngrok download failed: ${err.message}`);
+  }
+
+  try {
+    await extractArchive(archive, dir, isZip, bin);
+  } catch (err) {
+    await fsp.rm(archive, { force: true });
+    throw new Error(`ngrok extraction failed: ${err.message}`);
+  }
+
+  await fsp.rm(archive, { force: true });
+
+  if (process.platform !== "win32") {
+    await fsp.chmod(bin, 0o755);
+  }
+
+  if (!binExists(bin)) {
+    throw new Error(`ngrok binary not found at ${bin} after extraction. Please report this.`);
+  }
+
+  logger.info(`ngrok installed: ${bin}`);
+}
+
+function getBinPath() {
+  const ext = process.platform === "win32" ? ".exe" : "";
+  return path.resolve(config.ngrok.binDir || ".bin", `ngrok${ext}`);
+}
+
+function binExists(binPath) {
+  if (!fs.existsSync(binPath)) return false;
+  if (process.platform === "win32") return true;
+  try { fs.accessSync(binPath, fs.constants.X_OK); return true; } catch { return false; }
+}
+
+function getDownloadUrl() {
+  const plat = process.platform;
+  const arch = os.arch();
+
+  const map = {
+    linux:  { x64: "linux-amd64",  arm64: "linux-arm64",  arm: "linux-arm"  },
+    darwin: { x64: "darwin-amd64", arm64: "darwin-arm64"                     },
+    win32:  { x64: "windows-amd64"                                            },
+  };
+
+  const target = map[plat]?.[arch];
+  if (!target) {
+    throw new Error(
+      `No pre-built ngrok binary for ${plat}/${arch}. ` +
+      `Download manually from https://ngrok.com/download and place at .bin/ngrok`
+    );
+  }
+
+  const isZip = plat === "win32";
+  const ext   = isZip ? "zip" : "tgz";
+  return { url: `${NGROK_CDN}/ngrok-v3-stable-${target}.${ext}`, isZip };
+}
+
+function downloadFile(url, dest) {
+  return new Promise((resolve, reject) => {
+    const file = createWriteStream(dest);
+
+    const request = (targetUrl) => {
+      https.get(targetUrl, (res) => {
+        if (res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
+          return request(res.headers.location);
+        }
+        if (res.statusCode !== 200) {
+          return reject(new Error(`HTTP ${res.statusCode} from ${targetUrl}`));
+        }
+        res.pipe(file);
+        file.on("finish", () => file.close(resolve));
+        file.on("error",  (e) => { fsp.rm(dest, { force: true }).catch(() => {}); reject(e); });
+      }).on("error", reject);
+    };
+
+    request(url);
+  });
+}
+
+async function extractArchive(archivePath, destDir, isZip, expectedBin) {
+  if (isZip) {
+    const unzipper = await import("unzipper");
+    await new Promise((resolve, reject) => {
+      fs.createReadStream(archivePath)
+        .pipe(unzipper.Extract({ path: destDir }))
+        .on("close", resolve)
+        .on("error", reject);
+    });
+  } else {
+    const tar = await import("tar");
+    await tar.x({
+      file:   archivePath,
+      cwd:    destDir,
+      filter: (p) => p === "ngrok" || p.endsWith("/ngrok"),
+    });
+  }
+}
+
+// ── Tunnel management ─────────────────────────────────────────────────────────
+
+async function startTunnel(port) {
+  const bin  = getBinPath();
+  const args = ["http", String(port), "--log", "stderr", "--log-format", "json"];
+
+  if (config.ngrok.authToken) {
+    args.push("--authtoken", config.ngrok.authToken);
+  } else {
+    // Attempt unauthenticated — ngrok allows limited free tunnels without auth on some versions
+    logger.warn("Starting ngrok without NGROK_AUTHTOKEN — may fail. Add token at https://dashboard.ngrok.com");
+  }
+
+  logger.info(`Starting ngrok tunnel → localhost:${port}`);
+
+  return new Promise((resolve, reject) => {
+    let settled = false;
+
+    const done = (err, url) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      if (err) {
+        if (activeProcess) {
+          try { activeProcess.kill("SIGTERM"); } catch { /* ignore */ }
+          activeProcess = null;
+        }
+        reject(err);
+      } else {
+        activeUrl = url;
+        resolve(url);
+      }
+    };
+
+    const timer = setTimeout(() => {
+      done(new Error(
+        `ngrok tunnel did not start within ${STARTUP_MS / 1000}s. ` +
+        `Verify NGROK_AUTHTOKEN is set and network is accessible.`
+      ));
+    }, STARTUP_MS);
+
+    let proc;
+    try {
+      proc = spawn(bin, args, { stdio: ["ignore", "pipe", "pipe"], detached: false });
+    } catch (err) {
+      return done(new Error(`Failed to spawn ngrok: ${err.message}`));
+    }
+
+    activeProcess = proc;
+
+    proc.on("error", (err) => {
+      done(new Error(`ngrok spawn error: ${err.message}`));
+    });
+
+    proc.stderr.on("data", (data) => {
+      const msg = data.toString().trim();
+      // Parse JSON log lines for auth errors — surface them immediately
+      if (msg.startsWith("{")) {
+        try {
+          const parsed = JSON.parse(msg);
+          const errMsg = parsed.err || parsed.msg || "";
+          if (errMsg.toLowerCase().includes("authtoken") || errMsg.toLowerCase().includes("auth")) {
+            done(new Error(
+              `ngrok authentication failed: ${errMsg}\n` +
+              `   Fix: add NGROK_AUTHTOKEN to .env — get it at https://dashboard.ngrok.com`
+            ));
+          }
+        } catch { /* not JSON, ignore */ }
+      } else if (msg) {
+        logger.debug(`ngrok: ${msg}`);
+      }
+    });
+
+    proc.on("exit", (code, signal) => {
+      activeProcess = null;
+      if (!settled) {
+        done(new Error(
+          `ngrok exited unexpectedly (code ${code}, signal ${signal}). ` +
+          `Check NGROK_AUTHTOKEN is valid at https://dashboard.ngrok.com`
+        ));
+      }
+    });
+
+    const poll = async (elapsed) => {
+      if (settled || elapsed >= STARTUP_MS) return;
+      const url = await fetchExistingTunnel(port);
+      if (url) { logger.info(`Tunnel ready: ${url}`); done(null, url); return; }
+      setTimeout(() => poll(elapsed + POLL_INTERVAL_MS), POLL_INTERVAL_MS);
+    };
+
+    setTimeout(() => poll(0), 800);
+  });
+}
+
+async function fetchExistingTunnel(port) {
+  try {
+    const controller = new AbortController();
+    const timer      = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS);
+    const res        = await fetch(NGROK_API_URL, { signal: controller.signal });
+    clearTimeout(timer);
+    if (!res.ok) return null;
+
+    const data    = await res.json();
+    const tunnels = data.tunnels || [];
+    const match   = tunnels.find(t =>
+      t.proto === "https" && (
+        t.config?.addr?.includes(String(port)) ||
+        t.config?.addr === `localhost:${port}`  ||
+        t.config?.addr === `http://localhost:${port}`
+      )
+    );
+    return match?.public_url || null;
+  } catch {
+    return null;
+  }
+}
+
+// ── Helpers ───────────────────────────────────────────────────────────────────
+
+function extractPort(url) {
+  try {
+    const parsed = new URL(url);
+    if (parsed.port) return parseInt(parsed.port);
+    return parsed.protocol === "https:" ? 443 : 80;
+  } catch {
+    const m = url.match(/:(\d+)/);
+    return m ? parseInt(m[1]) : null;
+  }
+}