@testsmith/api-spector 0.7.1 → 0.7.3

package/bin/cli.js

@@ -18,6 +18,7 @@ const [, , cmd = 'ui', ...rest] = process.argv
 const COMMANDS = {
   ui:       { entrypoint: null,        runner: 'electron' },
   run:      { entrypoint: 'runner.js',  runner: 'node' },
+  flow:     { entrypoint: 'flow.js',    runner: 'node' },
   mock:     { entrypoint: 'mock.js',    runner: 'node' },
   record:   { entrypoint: 'record.js',  runner: 'node' },
   agents:   { entrypoint: 'agents.js',  runner: 'node' },
@@ -35,6 +36,7 @@ function printHelp() {
   console.log('  Usage:')
   console.log('    api-spector ui                            Launch the app')
   console.log('    api-spector run      --workspace <path>   Run tests from CLI')
+  console.log('    api-spector flow     list|run <name>       Run a visual flow from CLI')
   console.log('    api-spector mock     --workspace <path>   Start mock servers from CLI')
   console.log('    api-spector record   --upstream <url>     Record API traffic as mock stubs')
   console.log('    api-spector contract list|run             Manage & run pinned contract snapshots')

package/out/main/agents.js

@@ -2,7 +2,7 @@
 "use strict";
 const promises = require("node:fs/promises");
 const path = require("node:path");
-const cliCommon = require("./chunks/cli-common-Cq_cphpZ.js");
+const cliCommon = require("./chunks/cli-common-GnihVSjU.js");
 require("./chunks/data-files-BYqhsoPe.js");
 require("node:crypto");
 const AGENTS = {

package/out/main/chunks/{broker-client-BSTNMPtT.js → broker-client-VwFF9sbp.js}

@@ -3,7 +3,7 @@ const promises = require("node:fs/promises");
 const path = require("node:path");
 const crypto = require("node:crypto");
 const undici = require("undici");
-const requestExec = require("./request-exec-DLBjLZe1.js");
+const requestExec = require("./request-exec-CcLHtkwG.js");
 const Ajv = require("ajv");
 const jsYaml = require("js-yaml");
 require("node:http");

package/out/main/chunks/{cli-common-Cq_cphpZ.js → cli-common-GnihVSjU.js}

@@ -90,11 +90,24 @@ async function loadMocks(workspace, dir, onError) {
   }
   return mocks;
 }
+async function loadFlows(workspace, dir, onError) {
+  const flows = [];
+  for (const relPath of workspace.flows ?? []) {
+    try {
+      const raw = await promises.readFile(path.join(dir, relPath), "utf8");
+      flows.push(JSON.parse(raw));
+    } catch {
+      onError?.(relPath);
+    }
+  }
+  return flows;
+}
 exports.C = C;
 exports.color = color;
 exports.colorAlways = colorAlways;
 exports.loadCollections = loadCollections;
 exports.loadEnvironments = loadEnvironments;
+exports.loadFlows = loadFlows;
 exports.loadMocks = loadMocks;
 exports.loadWorkspace = loadWorkspace;
 exports.parseArgs = parseArgs;

package/out/main/chunks/flow-engine-DuO1iX7c.js

@@ -0,0 +1,533 @@
+"use strict";
+const IN = [{ id: "in" }];
+const OUT = () => [{ id: "out" }];
+const BLOCK_SPECS = {
+  start: {
+    type: "start",
+    category: "terminal",
+    label: "Start",
+    description: "Where the flow begins.",
+    inputs: [],
+    outputs: OUT
+  },
+  end: {
+    type: "end",
+    category: "terminal",
+    label: "End",
+    description: "Ends this path of the flow.",
+    inputs: IN,
+    outputs: () => []
+  },
+  // ── Action ──────────────────────────────────────────────────────────────
+  request: {
+    type: "request",
+    category: "action",
+    label: "Send Request",
+    description: "Send a saved request; routes success or fail on its response.",
+    inputs: IN,
+    outputs: () => [{ id: "success", label: "success" }, { id: "fail", label: "fail" }]
+  },
+  subflow: {
+    type: "subflow",
+    category: "action",
+    label: "Run Flow",
+    description: "Run another flow from this workspace.",
+    inputs: IN,
+    outputs: OUT
+  },
+  // ── Logic ───────────────────────────────────────────────────────────────
+  if: {
+    type: "if",
+    category: "logic",
+    label: "If",
+    description: "Route to true or false based on a JS condition.",
+    inputs: IN,
+    outputs: () => [{ id: "true", label: "true" }, { id: "false", label: "false" }],
+    defaultConfig: { expression: "sp.response.code === 200" }
+  },
+  condition: {
+    type: "condition",
+    category: "logic",
+    label: "Condition",
+    description: "Multi-way switch: the first matching case wins, else `else`.",
+    inputs: IN,
+    outputs: (config) => [
+      ...(config?.cases ?? []).map((c) => ({ id: c.id, label: c.label })),
+      { id: "else", label: "else" }
+    ],
+    defaultConfig: {
+      cases: [
+        { id: "case1", label: "ok", expression: "sp.response.code < 400" }
+      ]
+    }
+  },
+  validate: {
+    type: "validate",
+    category: "logic",
+    label: "Validate",
+    description: "Assert with sp.test(...); routes pass or fail.",
+    inputs: IN,
+    outputs: () => [{ id: "pass", label: "pass" }, { id: "fail", label: "fail" }],
+    defaultConfig: {
+      script: "sp.test('status is 2xx', () => {\n  sp.expect(sp.response.code).to.be.below(300);\n});"
+    }
+  },
+  evaluate: {
+    type: "evaluate",
+    category: "logic",
+    label: "Evaluate",
+    description: "Run JS to compute values and set variables.",
+    inputs: IN,
+    outputs: OUT,
+    defaultConfig: { script: "// sp.variables.set('id', sp.response.json().id)" }
+  },
+  setVar: {
+    type: "setVar",
+    category: "logic",
+    label: "Set Variable",
+    description: "Set a variable from an expression, in a chosen scope.",
+    inputs: IN,
+    outputs: OUT,
+    defaultConfig: { varName: "myVar", valueExpression: "sp.response.json()", scope: "local" }
+  },
+  delay: {
+    type: "delay",
+    category: "logic",
+    label: "Delay",
+    description: "Wait before continuing.",
+    inputs: IN,
+    outputs: OUT,
+    defaultConfig: { delayMs: 1e3 }
+  },
+  merge: {
+    type: "merge",
+    category: "logic",
+    label: "Or / Merge",
+    description: "Continue as soon as any one incoming branch arrives.",
+    inputs: IN,
+    outputs: OUT
+  },
+  // ── Looping ─────────────────────────────────────────────────────────────
+  forEach: {
+    type: "forEach",
+    category: "looping",
+    label: "For Each",
+    description: "Run the body once per item of a list; then continue on done.",
+    inputs: IN,
+    outputs: () => [{ id: "body", label: "body" }, { id: "done", label: "done" }],
+    defaultConfig: { expression: "sp.response.json()", itemVar: "item", indexVar: "index" }
+  },
+  repeat: {
+    type: "repeat",
+    category: "looping",
+    label: "Repeat",
+    description: "Run the body a fixed number of times, then continue on done.",
+    inputs: IN,
+    outputs: () => [{ id: "body", label: "body" }, { id: "done", label: "done" }],
+    defaultConfig: { count: 3, indexVar: "index" }
+  },
+  collect: {
+    type: "collect",
+    category: "looping",
+    label: "Collect",
+    description: "Append each iteration's value into a list variable.",
+    inputs: IN,
+    outputs: OUT,
+    defaultConfig: { intoVar: "results" }
+  },
+  // ── Visualize ───────────────────────────────────────────────────────────
+  display: {
+    type: "display",
+    category: "visualize",
+    label: "Display",
+    description: "Show a value in the run results (text, JSON or table).",
+    inputs: IN,
+    outputs: OUT,
+    defaultConfig: { message: "sp.response.json()", as: "json" }
+  },
+  log: {
+    type: "log",
+    category: "visualize",
+    label: "Log",
+    description: "Append a message to the run log.",
+    inputs: IN,
+    outputs: OUT,
+    defaultConfig: { message: "Reached this point" }
+  }
+};
+[
+  { category: "action", blocks: [BLOCK_SPECS.request, BLOCK_SPECS.subflow] },
+  { category: "logic", blocks: [BLOCK_SPECS.if, BLOCK_SPECS.condition, BLOCK_SPECS.validate, BLOCK_SPECS.evaluate, BLOCK_SPECS.setVar, BLOCK_SPECS.delay, BLOCK_SPECS.merge] },
+  { category: "looping", blocks: [BLOCK_SPECS.forEach, BLOCK_SPECS.repeat, BLOCK_SPECS.collect] },
+  { category: "visualize", blocks: [BLOCK_SPECS.display, BLOCK_SPECS.log] }
+];
+function normalizeFlow(raw) {
+  const nodes = (raw.nodes ?? []).map((n) => {
+    const legacy = n;
+    const type = legacy.type ?? legacy.kind ?? "request";
+    const config = { ...n.config ?? {} };
+    if (legacy.ref && !config.ref) config.ref = legacy.ref;
+    return {
+      id: n.id,
+      type,
+      position: n.position ?? { x: 0, y: 0 },
+      label: n.label,
+      color: n.color,
+      config
+    };
+  });
+  const requestIds = new Set(nodes.filter((n) => n.type === "request").map((n) => n.id));
+  const edges = (raw.edges ?? []).map((e) => {
+    let sourcePort = e.sourcePort;
+    if (requestIds.has(e.source) && (sourcePort == null || sourcePort === "out")) sourcePort = "success";
+    return { id: e.id, source: e.source, sourcePort, target: e.target, targetPort: e.targetPort };
+  });
+  return { version: "1.0", id: raw.id, name: raw.name, description: raw.description, nodes, edges };
+}
+function toScalar(v) {
+  if (v == null) return "";
+  if (typeof v === "object") return JSON.stringify(v);
+  return String(v);
+}
+function parseBody(body) {
+  if (body == null) return void 0;
+  try {
+    return JSON.parse(body);
+  } catch {
+    return body;
+  }
+}
+async function runFlow(flow, deps, options = {}) {
+  const startedAt = Date.now();
+  const maxSteps = deps.maxSteps ?? 1e4;
+  const ctx = {
+    envVars: { ...options.envVars ?? {} },
+    collectionVars: { ...options.collectionVars ?? {} },
+    globals: { ...options.globals ?? {} },
+    localVars: { ...options.localVars ?? {} },
+    response: null,
+    data: {}
+  };
+  const summary = { total: 0, passed: 0, failed: 0, errors: 0, durationMs: 0, blocks: [] };
+  const state = { steps: 0 };
+  const relTime = () => Date.now() - startedAt;
+  const takenEdges = /* @__PURE__ */ new Set();
+  const emitEdges = (blockId, blockType, ids) => {
+    if (ids.length === 0) return;
+    for (const id of ids) takenEdges.add(id);
+    deps.onEvent?.({ kind: "edge", blockId, blockType, edgeIds: ids, atMs: relTime() });
+  };
+  const scriptInput = () => ({
+    envVars: ctx.envVars,
+    collectionVars: ctx.collectionVars,
+    globals: ctx.globals,
+    localVars: ctx.localVars,
+    response: ctx.response,
+    data: ctx.data
+  });
+  const applyScopes = (r) => {
+    ctx.envVars = r.envVars;
+    ctx.collectionVars = r.collectionVars;
+    ctx.globals = r.globals;
+    ctx.localVars = r.localVars;
+  };
+  const mergedVars = () => ({
+    ...ctx.globals,
+    ...ctx.collectionVars,
+    ...ctx.envVars,
+    ...ctx.localVars
+  });
+  const record = (block, status, extra = {}) => {
+    const rec = {
+      blockId: block.id,
+      type: block.type,
+      label: block.label || BLOCK_SPECS[block.type].label,
+      status,
+      atMs: relTime(),
+      ...extra
+    };
+    summary.blocks.push(rec);
+    summary.total++;
+    if (status === "passed") summary.passed++;
+    else if (status === "failed") summary.failed++;
+    else if (status === "error") summary.errors++;
+    deps.onEvent?.({
+      kind: "block-result",
+      blockId: block.id,
+      blockType: block.type,
+      label: rec.label,
+      atMs: relTime(),
+      status,
+      httpStatus: extra.httpStatus,
+      durationMs: extra.durationMs,
+      error: extra.error,
+      testResults: extra.testResults,
+      iteration: extra.iteration,
+      vars: mergedVars()
+    });
+  };
+  const renderMessage = async (msg) => {
+    const r = await deps.evalExpression(msg, scriptInput());
+    applyScopes(r);
+    if (!r.error) return r.value;
+    if (deps.interpolate) return deps.interpolate(msg, mergedVars());
+    return msg;
+  };
+  async function runOne(current, stack) {
+    const nodeById = new Map(current.nodes.map((n) => [n.id, n]));
+    const outEdges = (block, port) => current.edges.filter((e) => {
+      if (e.source !== block.id) return false;
+      const sp = e.sourcePort ?? "out";
+      if (sp === port) return true;
+      return block.type === "request" && port === "success" && sp === "out";
+    });
+    async function execBlock(block, iteration) {
+      const cfg = block.config ?? {};
+      const label = block.label || BLOCK_SPECS[block.type].label;
+      switch (block.type) {
+        case "start":
+          return ["out"];
+        case "end":
+          return [];
+        case "merge":
+          return ["out"];
+        case "log": {
+          const value = await renderMessage(cfg.message ?? "");
+          const message = toScalar(value);
+          deps.onEvent?.({ kind: "log", blockId: block.id, blockType: block.type, label, atMs: relTime(), message });
+          record(block, "done", { iteration, message });
+          return ["out"];
+        }
+        case "display": {
+          const value = await renderMessage(cfg.message ?? "");
+          deps.onEvent?.({
+            kind: "display",
+            blockId: block.id,
+            blockType: block.type,
+            label,
+            atMs: relTime(),
+            display: { as: cfg.as ?? "json", value, label }
+          });
+          record(block, "done", { iteration, display: value });
+          return ["out"];
+        }
+        case "delay": {
+          const ms = Math.max(0, cfg.delayMs ?? 0);
+          deps.onEvent?.({ kind: "block-start", blockId: block.id, blockType: block.type, status: "running", iteration });
+          const t0 = Date.now();
+          await deps.sleep(ms);
+          record(block, "done", { iteration, durationMs: Date.now() - t0 });
+          return ["out"];
+        }
+        case "evaluate": {
+          deps.onEvent?.({ kind: "block-start", blockId: block.id, blockType: block.type, status: "running", iteration });
+          const r = await deps.runScript(cfg.script ?? "", scriptInput());
+          applyScopes(r);
+          record(block, r.error ? "error" : "done", { iteration, error: r.error, testResults: r.testResults });
+          return ["out"];
+        }
+        case "validate": {
+          deps.onEvent?.({ kind: "block-start", blockId: block.id, blockType: block.type, status: "running", iteration });
+          const r = await deps.runScript(cfg.script ?? "", scriptInput());
+          applyScopes(r);
+          const failed = Boolean(r.error) || (r.testResults ?? []).some((t) => !t.passed);
+          record(block, r.error ? "error" : failed ? "failed" : "passed", { iteration, error: r.error, testResults: r.testResults });
+          return [failed ? "fail" : "pass"];
+        }
+        case "setVar": {
+          const r = await deps.evalExpression(cfg.valueExpression ?? "undefined", scriptInput());
+          applyScopes(r);
+          const name = cfg.varName;
+          if (name) {
+            const scalar = toScalar(r.value);
+            switch (cfg.scope ?? "local") {
+              case "collection":
+                ctx.collectionVars[name] = scalar;
+                break;
+              case "environment":
+                ctx.envVars[name] = scalar;
+                break;
+              case "global":
+                ctx.globals[name] = scalar;
+                break;
+              default:
+                ctx.localVars[name] = scalar;
+                ctx.data[name] = r.value;
+                break;
+            }
+          }
+          record(block, r.error ? "error" : "done", { iteration, error: r.error });
+          return ["out"];
+        }
+        case "if": {
+          const r = await deps.evalExpression(cfg.expression ?? "false", scriptInput());
+          applyScopes(r);
+          if (r.error) {
+            record(block, "error", { iteration, error: r.error });
+            return ["false"];
+          }
+          record(block, "done", { iteration });
+          return [r.value ? "true" : "false"];
+        }
+        case "condition": {
+          for (const c of cfg.cases ?? []) {
+            const r = await deps.evalExpression(c.expression, scriptInput());
+            applyScopes(r);
+            if (!r.error && r.value) {
+              record(block, "done", { iteration });
+              return [c.id];
+            }
+          }
+          record(block, "done", { iteration });
+          return ["else"];
+        }
+        case "request": {
+          if (!cfg.ref) {
+            record(block, "error", { iteration, error: "No request selected" });
+            return ["fail"];
+          }
+          deps.onEvent?.({ kind: "block-start", blockId: block.id, blockType: block.type, status: "running", iteration });
+          const r = await deps.runRequest(cfg.ref, scriptInput());
+          if (!r) {
+            record(block, "error", { iteration, error: "Linked request not found" });
+            return ["fail"];
+          }
+          applyScopes(r);
+          ctx.response = r.response;
+          const ok = r.status === "passed" || r.status === "skipped";
+          const reqStatus = r.status === "skipped" ? "done" : r.status === "pending" ? "running" : r.status;
+          record(block, reqStatus, {
+            iteration,
+            httpStatus: r.httpStatus,
+            durationMs: r.durationMs,
+            error: r.error,
+            testResults: r.testResults,
+            method: r.method,
+            resolvedUrl: r.resolvedUrl
+          });
+          return [ok ? "success" : "fail"];
+        }
+        case "subflow": {
+          const sub = cfg.flowId ? deps.resolveFlow(cfg.flowId) : null;
+          if (!sub) {
+            record(block, "error", { iteration, error: "Linked flow not found" });
+            return ["out"];
+          }
+          if (stack.includes(sub.id)) {
+            record(block, "error", { iteration, error: "Recursive sub-flow blocked" });
+            return ["out"];
+          }
+          deps.onEvent?.({ kind: "block-start", blockId: block.id, blockType: block.type, status: "running", iteration });
+          await runOne(sub, [...stack, sub.id]);
+          record(block, "done", { iteration });
+          return ["out"];
+        }
+        case "forEach": {
+          const r = await deps.evalExpression(cfg.expression ?? "[]", scriptInput());
+          applyScopes(r);
+          if (r.error) {
+            record(block, "error", { iteration, error: r.error });
+            return ["done"];
+          }
+          const list = Array.isArray(r.value) ? r.value : r.value == null ? [] : [r.value];
+          const itemVar = cfg.itemVar || "item";
+          const indexVar = cfg.indexVar || "index";
+          const bodyEdges = outEdges(block, "body");
+          emitEdges(block.id, block.type, bodyEdges.map((e) => e.id));
+          const bodyTargets = bodyEdges.map((e) => e.target);
+          for (let i = 0; i < list.length; i++) {
+            ctx.data[itemVar] = list[i];
+            ctx.data[indexVar] = i;
+            ctx.localVars[itemVar] = toScalar(list[i]);
+            ctx.localVars[indexVar] = String(i);
+            await walk(bodyTargets, i);
+          }
+          record(block, "done", { iteration });
+          return ["done"];
+        }
+        case "repeat": {
+          const n = Math.max(0, Math.floor(cfg.count ?? 0));
+          const indexVar = cfg.indexVar || "index";
+          const bodyEdges = outEdges(block, "body");
+          emitEdges(block.id, block.type, bodyEdges.map((e) => e.id));
+          const bodyTargets = bodyEdges.map((e) => e.target);
+          for (let i = 0; i < n; i++) {
+            ctx.data[indexVar] = i;
+            ctx.localVars[indexVar] = String(i);
+            await walk(bodyTargets, i);
+          }
+          record(block, "done", { iteration });
+          return ["done"];
+        }
+        case "collect": {
+          const intoVar = cfg.intoVar || "results";
+          let value;
+          if (cfg.valueExpression) {
+            const r = await deps.evalExpression(cfg.valueExpression, scriptInput());
+            applyScopes(r);
+            value = r.value;
+          } else {
+            value = ctx.response ? parseBody(ctx.response.body) : void 0;
+          }
+          const arr = Array.isArray(ctx.data[intoVar]) ? ctx.data[intoVar] : [];
+          arr.push(value);
+          ctx.data[intoVar] = arr;
+          ctx.localVars[intoVar] = JSON.stringify(arr);
+          record(block, "done", { iteration });
+          return ["out"];
+        }
+        default:
+          return ["out"];
+      }
+    }
+    async function walk(startNodeIds, iteration) {
+      const queue = [...startNodeIds];
+      const firedMerges = /* @__PURE__ */ new Set();
+      while (queue.length) {
+        if (++state.steps > maxSteps) {
+          throw new Error("Flow exceeded the step limit — check for an unbounded loop or merge cycle.");
+        }
+        const id = queue.shift();
+        const block = nodeById.get(id);
+        if (!block) continue;
+        if (block.type === "merge") {
+          if (firedMerges.has(id)) continue;
+          firedMerges.add(id);
+        }
+        const ports = await execBlock(block, iteration);
+        const takenIds = [];
+        for (const port of ports) {
+          for (const e of outEdges(block, port)) {
+            queue.push(e.target);
+            takenIds.push(e.id);
+          }
+        }
+        emitEdges(id, block.type, takenIds);
+      }
+    }
+    const startBlock = current.nodes.find((n) => n.type === "start");
+    const roots = startBlock ? [startBlock.id] : current.nodes.filter((n) => !current.edges.some((e) => e.target === n.id)).map((n) => n.id);
+    await walk(roots);
+  }
+  const startInputs = flow.nodes.find((n) => n.type === "start")?.config?.inputs ?? [];
+  for (const { key, value } of startInputs) {
+    if (!key) continue;
+    const resolved = deps.interpolate ? deps.interpolate(value, mergedVars()) : value;
+    ctx.localVars[key] = resolved;
+    ctx.data[key] = resolved;
+  }
+  await runOne(flow, [flow.id]);
+  summary.durationMs = Date.now() - startedAt;
+  summary.variables = {
+    envVars: { ...ctx.envVars },
+    collectionVars: { ...ctx.collectionVars },
+    globals: { ...ctx.globals },
+    localVars: { ...ctx.localVars }
+  };
+  summary.data = ctx.data;
+  summary.traversedEdges = [...takenEdges];
+  return summary;
+}
+exports.BLOCK_SPECS = BLOCK_SPECS;
+exports.normalizeFlow = normalizeFlow;
+exports.runFlow = runFlow;

package/out/main/chunks/{handle-DDZ37J8G.js → handle-BY_jaVBT.js}

@@ -20,6 +20,8 @@ const IPC = {
     deleteWorkspaceFile: "file:deleteWorkspaceFile",
     saveMock: "file:saveMock",
     loadMock: "file:loadMock",
+    saveFlow: "file:saveFlow",
+    loadFlow: "file:loadFlow",
     loadHistory: "file:loadHistory",
     saveHistory: "file:saveHistory"
   },
@@ -58,6 +60,12 @@ const IPC = {
     /** Event: per-request progress pushed from main during a run. */
     progress: "runner:progress"
   },
+  // ─── Flow runner ───────────────────────────────────────────────────────────
+  flow: {
+    run: "flow:run",
+    /** Event: per-block progress pushed from main during a flow run. */
+    progress: "flow:progress"
+  },
   // ─── Run results export ────────────────────────────────────────────────────
   results: {
     save: "results:save"
@@ -226,6 +234,14 @@ const IPC = {
     pushDesignContract: "cloud:pushDesignContract",
     /** Publish a provider OpenAPI spec (PUT /api/provider-contracts). */
     pushSpec: "cloud:pushSpec",
+    /** Upload a self-contained flow definition (POST /api/flows). */
+    pushFlow: "cloud:pushFlow",
+    /** Trigger a server-side run of an uploaded flow (POST /api/flows/{slug}/run). */
+    runFlow: "cloud:runFlow",
+    /** Poll a flow run's status/result (GET /api/flows/{slug}/runs/{id}). */
+    getFlowRun: "cloud:getFlowRun",
+    /** Open a flow's page in the cloud UI. */
+    openFlow: "cloud:openFlow",
     /** Open the cloud deployment matrix in the browser. */
     openMatrix: "cloud:openMatrix"
   }

package/out/main/chunks/{import-CBAklepT.js → import-DR_r1DUP.js}

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const uuid = require("uuid");
-const soapHandler = require("./soap-handler-C_LCcPwE.js");
-require("./handle-DDZ37J8G.js");
+const soapHandler = require("./soap-handler-CkoLJHoI.js");
+require("./handle-BY_jaVBT.js");
 require("node:https");
 require("node:http");
 require("@xmldom/xmldom");