@testsmith/api-spector 0.4.6 → 0.4.8

package/out/main/index.js

@@ -22,12 +22,12 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 const electron = require("electron");
-const handle = require("./chunks/handle-BGYDylL2.js");
+const handle = require("./chunks/handle-rimXXdJH.js");
 const path = require("path");
 const fs = require("fs");
 const promises = require("fs/promises");
 const crypto = require("crypto");
-const requestExec = require("./chunks/request-exec-CBi2kL6s.js");
+const requestExec = require("./chunks/request-exec-BH-M3KqZ.js");
 const ipcValidate = require("./chunks/ipc-validate-k6KI8adf.js");
 const uuid = require("uuid");
 const jsYaml = require("js-yaml");
@@ -37,9 +37,9 @@ const requestCollection = require("./chunks/request-collection-CJoXpvOw.js");
 const mockServer = require("./chunks/mock-server-BxiXhP1m.js");
 const http = require("http");
 const WebSocket = require("ws");
-const soapHandler = require("./chunks/soap-handler-CAyUjzxB.js");
+const soapHandler = require("./chunks/soap-handler-BXx842MN.js");
 const os = require("os");
-const snapshots = require("./chunks/snapshots-BDe-B5iQ.js");
+const snapshots = require("./chunks/snapshots-CtYxkSLz.js");
 const simpleGit = require("simple-git");
 const recorder = require("./chunks/recorder-0Ij921El.js");
 require("tls");
@@ -544,7 +544,11 @@ function formatRequestError(err, context) {
   }
   return lines.join("\n");
 }
+const streamControllers = /* @__PURE__ */ new Map();
 function registerRequestHandler(ipc) {
+  handle.handleIpc(ipc, handle.IPC.request.stopStream, async (_e, streamId) => {
+    streamControllers.get(streamId)?.abort();
+  });
   handle.handleIpc(ipc, handle.IPC.request.send, async (_e, payload) => {
     ipcValidate.validateSendRequestPayload(payload);
     const {
@@ -554,9 +558,23 @@ function registerRequestHandler(ipc) {
       globals: payloadGlobals,
       proxy,
       tls,
-      piiMaskPatterns = []
+      piiMaskPatterns = [],
+      streamId,
+      forceStream
     } = payload;
     requestExec.applyRequestDefaults(req);
+    const maskEvent = (ev) => piiMaskPatterns.length ? { ...ev, data: requestExec.maskPii(ev.data, piiMaskPatterns), json: void 0 } : ev;
+    let abortController;
+    let flushTimer;
+    const pending = [];
+    const flushStream = () => {
+      if (pending.length) _e.sender.send(handle.IPC.request.streamEvent, { streamId, events: pending.splice(0) });
+    };
+    if (streamId) {
+      abortController = new AbortController();
+      streamControllers.set(streamId, abortController);
+      flushTimer = setInterval(flushStream, 40);
+    }
     const start = Date.now();
     const liveGlobals = requestExec.getGlobals();
     const mergedGlobals = { ...payloadGlobals, ...liveGlobals };
@@ -640,18 +658,27 @@ function registerRequestHandler(ipc) {
         tls,
         onSent: (sent) => {
           sentRequest = sent;
-        }
+        },
+        forceStream,
+        signal: abortController?.signal,
+        onStreamEvent: streamId ? (ev) => {
+          pending.push(maskEvent(ev));
+          if (pending.length >= 50) flushStream();
+        } : void 0
       });
       const maskedBody = requestExec.maskPii(exchange.responseBody, piiMaskPatterns);
       const maskedHeaders = requestExec.maskHeaders(exchange.rawHeaders, piiMaskPatterns);
       const bodySize = Buffer.byteLength(exchange.responseBody, "utf8");
+      const maskedEvents = exchange.events?.map(maskEvent);
+      const streamFields = exchange.streamed ? { streamed: true, events: maskedEvents, streamClose: exchange.streamClose, firstEventMs: exchange.firstEventMs } : {};
       response = {
         status: exchange.status,
         statusText: exchange.statusText,
         headers: maskedHeaders,
         body: maskedBody,
         bodySize,
-        durationMs: exchange.durationMs
+        durationMs: exchange.durationMs,
+        ...streamFields
       };
       scriptResponse = {
         status: exchange.status,
@@ -659,7 +686,8 @@ function registerRequestHandler(ipc) {
         headers: exchange.rawHeaders,
         body: exchange.responseBody,
         bodySize,
-        durationMs: exchange.durationMs
+        durationMs: exchange.durationMs,
+        ...exchange.streamed ? { streamed: true, events: exchange.events } : {}
       };
     } catch (err) {
       const diagnostic = formatRequestError(err, {
@@ -680,6 +708,12 @@ function registerRequestHandler(ipc) {
         error: diagnostic
       };
       scriptResponse = response;
+    } finally {
+      if (streamId) {
+        if (flushTimer) clearInterval(flushTimer);
+        flushStream();
+        streamControllers.delete(streamId);
+      }
     }
     const schemaTestResults = !response.error ? requestExec.buildSchemaTestResults(req.schema, scriptResponse.body) : [];
     let postTestResults = [];
@@ -889,21 +923,71 @@ function translateMaybe(src, format) {
 }
 function parseRequest(item, collectionAuth) {
   const req = typeof item.request === "string" ? { url: item.request, method: "GET" } : item.request ?? {};
+  const method = (req.method ?? "GET").toUpperCase();
+  const url = parseUrl(req.url);
+  const headers = parseHeaders$1(req.header);
+  const params = parseParams$1(req.url);
+  const body = parseBody$1(req.body);
+  const examples = parseExamples(item, { method, url, headers, params, body });
   return {
     id: uuid.v4(),
     name: item.name ?? "Request",
-    method: (req.method ?? "GET").toUpperCase(),
-    url: parseUrl(req.url),
-    headers: parseHeaders$1(req.header),
-    params: parseParams$1(req.url),
+    method,
+    url,
+    headers,
+    params,
     auth: parseAuth$1(req.auth ?? collectionAuth),
-    body: parseBody$1(req.body),
+    body,
     description: req.description ?? "",
     preRequestScript: translateMaybe(parseScript(item.event, "prerequest"), "postman"),
     postRequestScript: translateMaybe(parseScript(item.event, "test"), "postman"),
-    meta: {}
+    meta: {},
+    ...examples ? { examples } : {}
   };
 }
+function parseExamples(item, parent) {
+  const responses = item?.response;
+  if (!Array.isArray(responses) || responses.length === 0) return void 0;
+  const examples = [];
+  for (const r of responses) {
+    if (!r || typeof r !== "object") continue;
+    const orig = r.originalRequest;
+    const request = orig ? {
+      method: (orig.method ?? parent.method).toUpperCase(),
+      url: parseUrl(orig.url),
+      headers: parseHeaders$1(orig.header),
+      params: parseParams$1(orig.url),
+      body: parseBody$1(orig.body)
+    } : {
+      method: parent.method,
+      url: parent.url,
+      headers: parent.headers,
+      params: parent.params,
+      body: parent.body
+    };
+    const headers = {};
+    for (const h of Array.isArray(r.header) ? r.header : []) {
+      if (h && typeof h === "object" && h.key) headers[h.key] = h.value ?? "";
+    }
+    const body = typeof r.body === "string" ? r.body : "";
+    const code = typeof r.code === "number" ? r.code : 0;
+    examples.push({
+      id: uuid.v4(),
+      name: typeof r.name === "string" && r.name.trim() ? r.name : "Example",
+      request,
+      response: {
+        status: code,
+        statusText: typeof r.status === "string" ? r.status : "",
+        headers,
+        body,
+        bodySize: body.length,
+        durationMs: typeof r.responseTime === "number" ? r.responseTime : 0
+      },
+      source: "imported"
+    });
+  }
+  return examples.length ? examples : void 0;
+}
 function parseScript(events, listen) {
   if (!Array.isArray(events)) return void 0;
   const event = events.find((e) => e.listen === listen);
@@ -1063,6 +1147,45 @@ function buildBody(operation, spec) {
   }
   return { mode: "none" };
 }
+function buildExamples(operation, spec, baseParams, baseHeaders, baseBody) {
+  const json = resolve(spec, operation.requestBody?.content ?? {})["application/json"];
+  const bodyExamples = {};
+  if (json?.examples && typeof json.examples === "object") {
+    for (const [name, ex] of Object.entries(json.examples)) {
+      bodyExamples[name] = resolve(spec, ex)?.value;
+    }
+  }
+  const paramExamples = {};
+  for (const p of operation.parameters ?? []) {
+    if (!p?.name || p.in !== "query" && p.in !== "path") continue;
+    if (p.examples && typeof p.examples === "object") {
+      paramExamples[p.name] = {};
+      for (const [name, ex] of Object.entries(p.examples)) {
+        paramExamples[p.name][name] = resolve(spec, ex)?.value;
+      }
+    }
+  }
+  const names = /* @__PURE__ */ new Set([
+    ...Object.keys(bodyExamples),
+    ...Object.values(paramExamples).flatMap((m) => Object.keys(m))
+  ]);
+  if (names.size === 0) return void 0;
+  const examples = [];
+  for (const name of names) {
+    const body = name in bodyExamples && bodyExamples[name] !== void 0 ? { mode: "json", json: typeof bodyExamples[name] === "string" ? String(bodyExamples[name]) : JSON.stringify(bodyExamples[name], null, 2) } : baseBody;
+    const params = baseParams.some((pr) => paramExamples[pr.key]?.[name] !== void 0) ? baseParams.map((pr) => {
+      const v = paramExamples[pr.key]?.[name];
+      return v !== void 0 ? { ...pr, value: v === null ? "" : String(v) } : pr;
+    }) : baseParams;
+    examples.push({
+      id: uuid.v4(),
+      name,
+      request: { headers: baseHeaders, params, body },
+      source: "imported"
+    });
+  }
+  return examples.length ? examples : void 0;
+}
 function buildParams(operation) {
   return (operation.parameters ?? []).filter((p) => p.in === "query").map((p) => ({
     key: p.name,
@@ -1159,18 +1282,22 @@ function buildCollection(spec) {
       ];
       const rawOperation = pathItem[method];
       const responseSchema = buildResponseSchema(rawOperation, spec);
+      const headers = buildHeaders(opWithParams);
+      const body = buildBody(opWithParams, spec);
+      const examples = buildExamples(opWithParams, spec, params, headers, body);
       const req = {
         id: uuid.v4(),
         name: operation.summary ?? operation.operationId ?? `${method.toUpperCase()} ${pathStr}`,
         method: method.toUpperCase(),
         url: rewritePathTemplate(`${baseUrl}${pathStr}`),
-        headers: buildHeaders(opWithParams),
+        headers,
         params,
         auth: buildAuth(security, securitySchemes),
-        body: buildBody(opWithParams, spec),
+        body,
         description: operation.description ?? "",
         meta: { tags },
-        ...responseSchema ? { schema: responseSchema } : {}
+        ...responseSchema ? { schema: responseSchema } : {},
+        ...examples ? { examples } : {}
       };
       requests[req.id] = req;
       if (!foldersByTag[tag]) {
@@ -4899,8 +5026,24 @@ async function resolveSnapshotSpec(relPath) {
 function registerContractHandlers(ipc) {
   handle.handleIpc(ipc, handle.IPC.contract.run, async (_e, payload) => {
     ipcValidate.validateContractRunPayload(payload);
-    const { mode, requests, envVars, collectionVars = {}, requestBaseUrl, providerBaseUrl, stateHandlerUrl } = payload;
+    const { mode, envVars, collectionVars = {}, requestBaseUrl, providerBaseUrl, stateHandlerUrl } = payload;
+    let requests = payload.requests;
     let { specUrl, specPath } = payload;
+    if (mode !== "provider") {
+      const designReqs = await snapshots.loadDesignContractRequests(
+        { designContracts: payload.designContracts },
+        getWorkspaceDir() ?? void 0
+      );
+      const keyOf = (r) => `${r.method} ${r.url} ${r.name}`;
+      const seen = new Set(requests.map(keyOf));
+      const fresh = designReqs.filter((r) => !seen.has(keyOf(r)));
+      if (fresh.length) {
+        requests = [...requests, ...fresh];
+        if (envVars["baseUrl"] === void 0 && collectionVars["baseUrl"] === void 0) {
+          collectionVars["baseUrl"] = "";
+        }
+      }
+    }
     if (payload.specSnapshotRelPath) {
       const resolved = await resolveSnapshotSpec(payload.specSnapshotRelPath);
       specPath = resolved.specPath;
@@ -4931,6 +5074,16 @@ function registerContractHandlers(ipc) {
     await promises.writeFile(filePath, snapshots.reportToHtml(report, { generatedAt: (/* @__PURE__ */ new Date()).toISOString(), ...meta }), "utf8");
     return true;
   });
+  handle.handleIpc(ipc, handle.IPC.contract.exportDesignPact, async (_e, contract) => {
+    const dir = getWorkspaceDir();
+    if (!dir) throw new Error("No workspace open — open or save a workspace first.");
+    const safe = (s) => (s || "unnamed").replace(/[^a-zA-Z0-9._-]+/g, "-");
+    const relPath = path.join("pacts", `${safe(contract.consumer)}-${safe(contract.provider)}.pact.json`);
+    const fullPath = path.join(dir, relPath);
+    await promises.mkdir(path.join(dir, "pacts"), { recursive: true });
+    await promises.writeFile(fullPath, JSON.stringify(snapshots.designContractToPact(contract), null, 2), "utf8");
+    return relPath;
+  });
   handle.handleIpc(ipc, handle.IPC.contract.captureSnapshot, async (_e, opts) => {
     const dir = getWorkspaceDir();
     if (!dir) throw new Error("No workspace open - cannot capture snapshot.");
@@ -5165,6 +5318,198 @@ function registerRecordHandlers(ipc, getWebContents) {
     return recorder.entriesToMockServer(entries, upstream, name, port);
   });
 }
+const CLOUD_TOKEN_REF = "cloud:token";
+const CLOUD_ENDPOINT = (process.env["API_SPECTOR_CLOUD_ENDPOINT"] || "https://api-spector.dev").replace(/\/+$/, "");
+async function cloudFetch(path2, method, body) {
+  const token = await requestExec.getSecret(CLOUD_TOKEN_REF);
+  if (!token) throw new Error("No cloud API token set. Add one in Settings → Cloud.");
+  const dispatcher = await requestExec.buildDispatcher();
+  const url = CLOUD_ENDPOINT + path2;
+  let res;
+  try {
+    res = await undici.fetch(url, {
+      method,
+      headers: {
+        "Content-Type": "application/json",
+        Accept: "application/json",
+        Authorization: `Bearer ${token}`
+      },
+      body: body === void 0 ? void 0 : JSON.stringify(body),
+      dispatcher
+    });
+  } catch (err) {
+    const msg = err.message;
+    const hint = /ECONNREFUSED|fetch failed|connect|ENOTFOUND/i.test(msg) ? ` — is API Spector Cloud running and reachable at ${CLOUD_ENDPOINT}? (set API_SPECTOR_CLOUD_ENDPOINT or start the broker)` : "";
+    throw new Error(`Could not reach ${url}: ${msg}${hint}`);
+  }
+  const text = await res.text();
+  let json;
+  try {
+    json = text ? JSON.parse(text) : {};
+  } catch {
+    json = { raw: text };
+  }
+  if (!res.ok) {
+    let detail = json?.error || json?.message || (res.status === 401 ? "Unauthorized (check your token)" : `HTTP ${res.status}`);
+    if (res.status === 403 && json?.limit != null) detail += ` (plan limit: ${json.limit})`;
+    if (res.status === 405) detail = `HTTP 405 from ${CLOUD_ENDPOINT} — this does not look like the API Spector Cloud API (set API_SPECTOR_CLOUD_ENDPOINT to your broker URL).`;
+    throw new Error(detail);
+  }
+  return json;
+}
+function interpolateStatic(str, vars) {
+  return str.replace(/\{\{([^}]+)\}\}/g, (m, key) => {
+    const trimmed = String(key).trim();
+    return Object.prototype.hasOwnProperty.call(vars, trimmed) ? vars[trimmed] : m;
+  });
+}
+function resolveRequest(req, vars) {
+  return {
+    id: req.id,
+    name: req.name,
+    method: req.method,
+    url: requestExec.buildUrl(req.url, req.params ?? [], vars),
+    headers: resolveHeaders(req.headers, vars),
+    params: [],
+    // folded into url; empty so the runner doesn't re-append
+    auth: req.auth ?? { type: "none" },
+    body: resolveBody(req.body, vars),
+    preRequestScript: req.preRequestScript || void 0,
+    postRequestScript: req.postRequestScript || void 0
+  };
+}
+function resolveHeaders(headers, vars) {
+  return (headers ?? []).filter((h) => h.enabled !== false && h.key).map((h) => ({ key: interpolateStatic(h.key, vars), value: interpolateStatic(h.value ?? "", vars), enabled: true }));
+}
+function resolveBody(body, vars) {
+  if (!body || !body.mode || body.mode === "none") return { mode: "none" };
+  const b = { ...body };
+  if (body.mode === "json" && body.json != null) b.json = interpolateStatic(body.json, vars);
+  else if (body.mode === "raw" && body.raw != null) b.raw = interpolateStatic(body.raw, vars);
+  else if (body.mode === "form" && body.form) {
+    b.form = body.form.map((f) => ({ ...f, key: interpolateStatic(f.key, vars), value: interpolateStatic(f.value ?? "", vars) }));
+  } else if (body.mode === "graphql" && body.graphql) {
+    b.graphql = {
+      ...body.graphql,
+      query: interpolateStatic(body.graphql.query ?? "", vars),
+      variables: interpolateStatic(body.graphql.variables ?? "", vars)
+    };
+  } else if (body.mode === "soap" && body.soap) {
+    b.soap = { ...body.soap, envelope: interpolateStatic(body.soap.envelope ?? "", vars) };
+  }
+  return b;
+}
+function setVarNames(reqs) {
+  const names = /* @__PURE__ */ new Set();
+  const re = /sp\.(?:environment|collectionVariables|variables|globals)\.set\(\s*['"`]([^'"`]+)['"`]/g;
+  for (const r of reqs) {
+    for (const script of [r.preRequestScript, r.postRequestScript]) {
+      if (!script) continue;
+      let m;
+      while ((m = re.exec(script)) !== null) names.add(m[1]);
+    }
+  }
+  return names;
+}
+function omitKeys(vars, names) {
+  if (!names.size) return vars;
+  const out = {};
+  for (const [k, v] of Object.entries(vars)) if (!names.has(k)) out[k] = v;
+  return out;
+}
+function slugify(name) {
+  return (name || "mock").toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 63) || "mock";
+}
+function registerCloudHandlers(ipc) {
+  handle.handleIpc(ipc, handle.IPC.cloud.test, async () => {
+    return cloudFetch("/api/me", "GET");
+  });
+  handle.handleIpc(ipc, handle.IPC.cloud.pushMock, async (_e, server) => {
+    const payload = {
+      name: server.name,
+      slug: slugify(server.name),
+      enabled: true,
+      auth_type: "none",
+      routes: (server.routes ?? []).map((r) => ({
+        method: r.method,
+        path: r.path,
+        status: r.statusCode,
+        headers: r.headers ?? {},
+        body: r.body ?? "",
+        delay: r.delay ?? 0,
+        script: r.script ?? null
+      }))
+    };
+    return cloudFetch("/api/mocks", "POST", payload);
+  });
+  handle.handleIpc(ipc, handle.IPC.cloud.getMock, async (_e, name) => {
+    return cloudFetch("/api/mocks/" + encodeURIComponent(slugify(name)), "GET");
+  });
+  handle.handleIpc(ipc, handle.IPC.cloud.pushPact, async (_e, input) => {
+    const pact = snapshots.exportPact(input.consumer, input.provider, input.requests ?? []);
+    return cloudFetch("/api/contracts", "PUT", {
+      consumer: input.consumer,
+      consumerVersion: input.consumerVersion,
+      provider: input.provider,
+      content: pact
+    });
+  });
+  handle.handleIpc(ipc, handle.IPC.cloud.pushDesignContract, async (_e, input) => {
+    const pact = snapshots.designContractToPact(input.contract);
+    return cloudFetch("/api/contracts", "PUT", {
+      consumer: input.contract.consumer,
+      consumerVersion: input.consumerVersion,
+      provider: input.contract.provider,
+      content: pact
+    });
+  });
+  handle.handleIpc(ipc, handle.IPC.cloud.pushSpec, async (_e, input) => {
+    let specText = input.spec;
+    if (!specText && input.specUrl) {
+      const res = await undici.fetch(input.specUrl, { dispatcher: await requestExec.buildDispatcher() });
+      if (!res.ok) throw new Error(`Could not fetch spec from ${input.specUrl} (HTTP ${res.status})`);
+      specText = await res.text();
+    }
+    if (!specText) throw new Error("Provide an OpenAPI spec (text or a spec URL).");
+    let spec;
+    try {
+      spec = JSON.parse(specText);
+    } catch {
+      spec = jsYaml.load(specText);
+    }
+    if (!spec || typeof spec !== "object") {
+      throw new Error("Could not parse the OpenAPI spec (expected JSON or YAML).");
+    }
+    return cloudFetch("/api/provider-contracts", "PUT", {
+      pacticipant: input.pacticipant,
+      version: input.version,
+      spec
+    });
+  });
+  handle.handleIpc(ipc, handle.IPC.cloud.openMatrix, async () => {
+    await electron.shell.openExternal(CLOUD_ENDPOINT + "/matrix");
+  });
+  handle.handleIpc(ipc, handle.IPC.cloud.pushMonitor, async (_e, input) => {
+    const { request, environment, collectionVars, globals } = input;
+    const envVars = await requestExec.buildEnvVars(environment);
+    const liveGlobals = { ...globals, ...requestExec.getGlobals() };
+    const staticVars = requestExec.mergeVars(envVars, collectionVars ?? {}, liveGlobals, {}, {});
+    const setup = input.setup ?? [];
+    const resolveVars = omitKeys(staticVars, setVarNames(setup));
+    const monitorRequest = resolveRequest(request, resolveVars);
+    const setupRequests = setup.map((h) => resolveRequest(h, resolveVars));
+    const payload = {
+      name: input.name || request.name || "Monitor",
+      target_url: monitorRequest.url,
+      method: request.method,
+      expected_status: input.expectedStatus ?? 200,
+      interval_seconds: input.intervalSeconds ?? 300,
+      request: monitorRequest,
+      setup: setupRequests
+    };
+    return cloudFetch("/api/monitors", "POST", payload);
+  });
+}
 const REGISTRY_URL = "https://registry.npmjs.org/@testsmith/api-spector/latest";
 function isNewer(a, b) {
   const core = (v) => v.split("-")[0].split(".").map((n) => parseInt(n, 10) || 0);
@@ -5175,7 +5520,7 @@ function isNewer(a, b) {
   return a2 > b2;
 }
 async function checkForUpdate() {
-  const current = "0.4.6";
+  const current = "0.4.8";
   try {
     const res = await fetch(REGISTRY_URL, { signal: AbortSignal.timeout(4e3) });
     if (!res.ok) return null;
@@ -5295,6 +5640,7 @@ electron.app.whenReady().then(async () => {
   registerContractHandlers(electron.ipcMain);
   registerGitHandlers(electron.ipcMain);
   registerRecordHandlers(electron.ipcMain, () => electron.BrowserWindow.getAllWindows()[0]?.webContents ?? null);
+  registerCloudHandlers(electron.ipcMain);
   handle.handleIpc(electron.ipcMain, handle.IPC.shell.openExternal, (_e, url) => electron.shell.openExternal(url));
   handle.handleIpc(electron.ipcMain, handle.IPC.app.checkUpdate, () => checkForUpdate());
   createWindow();

package/out/main/lib.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const mockServer = require("./chunks/mock-server-BxiXhP1m.js");
-const requestExec = require("./chunks/request-exec-CBi2kL6s.js");
+const requestExec = require("./chunks/request-exec-BH-M3KqZ.js");
 require("http");
 require("crypto");
 require("vm");
@@ -10,7 +10,7 @@ require("@xmldom/xmldom");
 require("undici");
 require("fs/promises");
 require("tls");
-require("./chunks/handle-BGYDylL2.js");
+require("./chunks/handle-rimXXdJH.js");
 require("path");
 require("tv4");
 require("jsonpath-plus");

package/out/main/mock.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 "use strict";
 const mockServer = require("./chunks/mock-server-BxiXhP1m.js");
-const cliCommon = require("./chunks/cli-common-CDQY1erJ.js");
+const cliCommon = require("./chunks/cli-common-BKYgsbGB.js");
 require("http");
 require("crypto");
 require("vm");

package/out/main/record.js

@@ -3,7 +3,7 @@
 const promises = require("fs/promises");
 const path = require("path");
 const recorder = require("./chunks/recorder-0Ij921El.js");
-const cliCommon = require("./chunks/cli-common-CDQY1erJ.js");
+const cliCommon = require("./chunks/cli-common-BKYgsbGB.js");
 require("http");
 require("crypto");
 require("undici");

package/out/main/runner.js

@@ -2,13 +2,13 @@
 "use strict";
 const promises = require("fs/promises");
 const path = require("path");
-const requestExec = require("./chunks/request-exec-CBi2kL6s.js");
+const requestExec = require("./chunks/request-exec-BH-M3KqZ.js");
 const requestCollection = require("./chunks/request-collection-CJoXpvOw.js");
 const environments = require("./chunks/environments-iM3SUM-4.js");
-const cliCommon = require("./chunks/cli-common-CDQY1erJ.js");
+const cliCommon = require("./chunks/cli-common-BKYgsbGB.js");
 require("undici");
 require("tls");
-require("./chunks/handle-BGYDylL2.js");
+require("./chunks/handle-rimXXdJH.js");
 require("crypto");
 require("dayjs");
 require("vm");
@@ -397,7 +397,7 @@ async function main() {
   } else if (!envName && workspace.settings?.defaultEnvironment && !env) {
     console.warn(cliCommon.color(`Warning: default environment "${workspace.settings.defaultEnvironment}" not found. Running without environment.`, cliCommon.C.yellow));
   }
-  const version = `v${"0.4.6"}`;
+  const version = `v${"0.4.8"}`;
   console.log("");
   console.log(cliCommon.color("  API Test Runner" + (version ? ` ${version}` : ""), cliCommon.C.bold, cliCommon.C.white));
   console.log(cliCommon.color(`  Workspace:   ${wsPath}`, cliCommon.C.gray));

package/out/main/wsdl.js

@@ -4,12 +4,13 @@ const promises = require("fs/promises");
 const path = require("path");
 const https = require("https");
 const http = require("http");
-const soapHandler = require("./chunks/soap-handler-CAyUjzxB.js");
-const _import = require("./chunks/import-CUcjlmSK.js");
-const cliCommon = require("./chunks/cli-common-CDQY1erJ.js");
-require("./chunks/handle-BGYDylL2.js");
+const soapHandler = require("./chunks/soap-handler-BXx842MN.js");
+const _import = require("./chunks/import-DcenB5Q_.js");
+const cliCommon = require("./chunks/cli-common-BKYgsbGB.js");
+require("./chunks/handle-rimXXdJH.js");
 require("@xmldom/xmldom");
 require("uuid");
+require("crypto");
 function fetchUrl(url) {
   return new Promise((resolveP, rejectP) => {
     const lib = url.startsWith("https") ? https : http;