@testsmith/api-spector 0.2.2 → 0.2.4

package/bin/cli.js

@@ -6,15 +6,34 @@ const { spawn } = require('child_process')
 
 const [, , cmd = 'ui', ...rest] = process.argv
 
+// ─── Command dispatch ────────────────────────────────────────────────────────
+//
+// Each entry maps a top-level command to the bundled JS file that handles it.
+// `entrypoint: null` is reserved for `ui`, which spawns electron itself rather
+// than a node script. Adding a new CLI surface is one line here + one entry in
+// electron.vite.config.ts.
+
+const COMMANDS = {
+  ui:       { entrypoint: null,        runner: 'electron' },
+  run:      { entrypoint: 'runner.js',  runner: 'node' },
+  mock:     { entrypoint: 'mock.js',    runner: 'node' },
+  record:   { entrypoint: 'record.js',  runner: 'node' },
+  agents:   { entrypoint: 'agents.js',  runner: 'node' },
+  contract: { entrypoint: 'contract.js',runner: 'node' },
+  wsdl:     { entrypoint: 'wsdl.js',    runner: 'node' },
+}
+
 function printHelp() {
   console.log('')
   console.log('  API Spector — local-first API testing tool')
   console.log('')
   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 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 run      --workspace <path>   Run tests 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')
+  console.log('    api-spector wsdl     describe|import-*    Inspect a WSDL or import as collection/mock')
   console.log('')
   console.log('  Options:')
   console.log('    api-spector agents init <name>            Initialize AI agent files')
@@ -33,44 +52,34 @@ function printHelp() {
 if (cmd === '--help' || cmd === '-h') {
   printHelp()
   process.exit(0)
-} else if (cmd === 'ui') {
+}
+
+const command = COMMANDS[cmd]
+if (!command) {
+  console.error(`API Spector — unknown command: "${cmd}"`)
+  printHelp()
+  process.exit(1)
+}
+
+// ui: spawn electron with the app dir
+if (command.runner === 'electron') {
   const electron = require('electron')
   const appDir = path.join(__dirname, '..')
+  // Forward the user's cwd so the main process can decide whether to open a
+  // workspace in this folder, or fall through to the welcome screen. Without
+  // this, the app would always auto-load the previously-opened workspace
+  // even when launched from an empty/different directory.
   const proc = spawn(String(electron), [appDir, ...rest], {
     stdio: 'inherit',
-    env: process.env,
-  })
-  proc.on('close', code => process.exit(code ?? 0))
-} else if (cmd === 'run') {
-  const runnerPath = path.join(__dirname, '..', 'out', 'main', 'runner.js')
-  const proc = spawn(process.execPath, [runnerPath, ...rest], {
-    stdio: 'inherit',
-    env: process.env,
-  })
-  proc.on('close', code => process.exit(code ?? 0))
-} else if (cmd === 'mock') {
-  const mockPath = path.join(__dirname, '..', 'out', 'main', 'mock.js')
-  const proc = spawn(process.execPath, [mockPath, ...rest], {
-    stdio: 'inherit',
-    env: process.env,
-  })
-  proc.on('close', code => process.exit(code ?? 0))
-} else if (cmd === 'record') {
-  const recordPath = path.join(__dirname, '..', 'out', 'main', 'record.js')
-  const proc = spawn(process.execPath, [recordPath, ...rest], {
-    stdio: 'inherit',
-    env: process.env,
+    env: { ...process.env, API_SPECTOR_LAUNCH_CWD: process.cwd() },
   })
   proc.on('close', code => process.exit(code ?? 0))
-} else if (cmd === 'agents') {
-  const agentsPath = path.join(__dirname, '..', 'out', 'main', 'agents.js')
-  const proc = spawn(process.execPath, [agentsPath, ...rest], {
+} else {
+  // node-runnable bundles in out/main/<entrypoint>
+  const target = path.join(__dirname, '..', 'out', 'main', command.entrypoint)
+  const proc = spawn(process.execPath, [target, ...rest], {
     stdio: 'inherit',
     env: process.env,
   })
   proc.on('close', code => process.exit(code ?? 0))
-} else {
-  console.error(`API Spector — unknown command: "${cmd}"`)
-  printHelp()
-  process.exit(1)
 }

package/out/main/chunks/auth-builder-B7-LgcGr.js

@@ -0,0 +1,373 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+const crypto = require("crypto");
+const promises = require("fs/promises");
+const path = require("path");
+const dayjs = require("dayjs");
+const vm = require("vm");
+function _interopNamespaceDefault(e) {
+  const n = Object.create(null, { [Symbol.toStringTag]: { value: "Module" } });
+  if (e) {
+    for (const k in e) {
+      if (k !== "default") {
+        const d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: () => e[k]
+        });
+      }
+    }
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+const vm__namespace = /* @__PURE__ */ _interopNamespaceDefault(vm);
+const MASTER_KEY_ENV = "API_SPECTOR_MASTER_KEY";
+let secretStore = {};
+let secretStorePath = null;
+async function initSecretStore(userDataPath) {
+  secretStorePath = path.join(userDataPath, "secrets.json");
+  try {
+    const raw = await promises.readFile(secretStorePath, "utf8");
+    secretStore = JSON.parse(raw);
+  } catch {
+    secretStore = {};
+  }
+}
+async function persistSecretStore() {
+  if (!secretStorePath) return;
+  await promises.writeFile(secretStorePath, JSON.stringify(secretStore, null, 2), "utf8");
+}
+function getSafeStorage() {
+  try {
+    const { safeStorage } = require("electron");
+    if (typeof safeStorage?.isEncryptionAvailable === "function") return safeStorage;
+    return null;
+  } catch {
+    return null;
+  }
+}
+function registerSecretHandlers(ipc) {
+  ipc.handle("secret:checkMasterKey", () => {
+    return { set: Boolean(process.env[MASTER_KEY_ENV]) };
+  });
+  ipc.handle("secret:setMasterKey", (_e, value) => {
+    process.env[MASTER_KEY_ENV] = value;
+  });
+  ipc.handle("secret:set", async (_e, ref, value) => {
+    const ss = getSafeStorage();
+    if (!ss || !ss.isEncryptionAvailable()) {
+      throw new Error("OS encryption is not available — set the secret via environment variable instead");
+    }
+    secretStore[ref] = ss.encryptString(value).toString("base64");
+    await persistSecretStore();
+  });
+}
+function decryptSecret(encrypted, salt, iv, password) {
+  const saltBuf = Buffer.from(salt, "base64");
+  const ivBuf = Buffer.from(iv, "base64");
+  const encBuf = Buffer.from(encrypted, "base64");
+  const key = crypto.pbkdf2Sync(password, saltBuf, 1e5, 32, "sha256");
+  const authTag = encBuf.subarray(encBuf.length - 16);
+  const ciphertext = encBuf.subarray(0, encBuf.length - 16);
+  const decipher = crypto.createDecipheriv("aes-256-gcm", key, ivBuf);
+  decipher.setAuthTag(authTag);
+  return Buffer.concat([decipher.update(ciphertext), decipher.final()]).toString("utf8");
+}
+async function getSecret(ref) {
+  const stored = secretStore[ref];
+  if (stored) {
+    const ss = getSafeStorage();
+    if (ss && ss.isEncryptionAvailable()) {
+      try {
+        return ss.decryptString(Buffer.from(stored, "base64"));
+      } catch {
+      }
+    }
+  }
+  return process.env[ref] ?? null;
+}
+let _fakerCache = null;
+async function getFaker() {
+  if (!_fakerCache) _fakerCache = await import("@faker-js/faker");
+  return _fakerCache.faker;
+}
+let _exprContext = null;
+async function buildDynamicVars() {
+  const faker = await getFaker();
+  const now = dayjs();
+  _exprContext = { faker, dayjs };
+  return {
+    $uuid: faker.string.uuid(),
+    $timestamp: String(Date.now()),
+    $isoTimestamp: now.toISOString(),
+    $randomInt: String(faker.number.int({ min: 0, max: 1e3 })),
+    $randomFloat: String(faker.number.float({ min: 0, max: 1e3, fractionDigits: 2 })),
+    $randomBoolean: String(faker.datatype.boolean()),
+    $randomEmail: faker.internet.email(),
+    $randomUsername: faker.internet.username(),
+    $randomPassword: faker.internet.password(),
+    $randomFullName: faker.person.fullName(),
+    $randomFirstName: faker.person.firstName(),
+    $randomLastName: faker.person.lastName(),
+    $randomWord: faker.lorem.word(),
+    $randomPhrase: faker.lorem.sentence(),
+    $randomUrl: faker.internet.url(),
+    $randomIp: faker.internet.ip(),
+    $randomHexColor: faker.color.rgb({ format: "hex", casing: "lower" })
+  };
+}
+function interpolate(str, vars) {
+  return str.replace(/\{\{([^}]+)\}\}/g, (match, key) => {
+    const trimmed = key.trim();
+    if (trimmed in vars) return vars[trimmed];
+    if (_exprContext && (trimmed.includes(".") || trimmed.includes("("))) {
+      try {
+        const result = vm__namespace.runInNewContext(trimmed, _exprContext);
+        if (result !== void 0 && result !== null) return String(result);
+      } catch {
+      }
+    }
+    return match;
+  });
+}
+function buildUrl(baseUrl, params, vars) {
+  const templateTokens = /* @__PURE__ */ new Set();
+  baseUrl.replace(/\{\{([^}]+)\}\}/g, (_m, name) => {
+    templateTokens.add(String(name).trim());
+    return "";
+  });
+  const enabled = (params ?? []).filter((p) => p.enabled && p.key);
+  const pathRows = [];
+  const queryRows = [];
+  for (const p of enabled) {
+    const isPath = p.paramType === "path" || templateTokens.has(p.key);
+    if (isPath) pathRows.push(p);
+    else queryRows.push(p);
+  }
+  const mergedVars = pathRows.length ? {
+    ...vars,
+    ...Object.fromEntries(pathRows.map((p) => [p.key, interpolate(p.value, vars)]))
+  } : vars;
+  const url = interpolate(baseUrl, mergedVars);
+  if (!queryRows.length) return url;
+  const sep = url.includes("?") ? "&" : "?";
+  const qs = queryRows.map((p) => `${encodeURIComponent(interpolate(p.key, vars))}=${encodeURIComponent(interpolate(p.value, vars))}`).join("&");
+  return url + sep + qs;
+}
+async function buildEnvVars(environment) {
+  const vars = {};
+  if (!environment) return vars;
+  const masterKey = process.env["API_SPECTOR_MASTER_KEY"];
+  for (const v of environment.variables) {
+    if (!v.enabled) continue;
+    if (v.envRef) {
+      const envValue = process.env[v.envRef];
+      if (envValue !== void 0) vars[v.key] = envValue;
+    } else if (v.secret && v.secretEncrypted && v.secretSalt && v.secretIv) {
+      if (masterKey) {
+        try {
+          vars[v.key] = decryptSecret(v.secretEncrypted, v.secretSalt, v.secretIv, masterKey);
+        } catch {
+        }
+      }
+      if (vars[v.key] === void 0 && process.env[v.key] !== void 0) {
+        vars[v.key] = process.env[v.key];
+      }
+    } else if (v.secret) {
+      if (process.env[v.key] !== void 0) {
+        vars[v.key] = process.env[v.key];
+      }
+    } else {
+      vars[v.key] = v.value;
+    }
+  }
+  return vars;
+}
+function mergeVars(envVars, collectionVars, globals, localVars = {}, dynamicVars = {}) {
+  return { ...dynamicVars, ...globals, ...collectionVars, ...envVars, ...localVars };
+}
+async function buildAuthHeaders(auth, vars) {
+  const headers = {};
+  if (auth.type === "bearer") {
+    let token = auth.token ?? "";
+    if (!token && auth.tokenSecretRef) token = await getSecret(auth.tokenSecretRef) ?? "";
+    token = interpolate(token, vars);
+    if (token) headers["Authorization"] = `Bearer ${token}`;
+  }
+  if (auth.type === "basic") {
+    let password = auth.password ?? "";
+    if (!password && auth.passwordSecretRef) password = await getSecret(auth.passwordSecretRef) ?? "";
+    password = interpolate(password, vars);
+    const username = interpolate(auth.username ?? "", vars);
+    headers["Authorization"] = `Basic ${Buffer.from(`${username}:${password}`).toString("base64")}`;
+  }
+  if (auth.type === "apikey" && auth.apiKeyIn === "header") {
+    let value = auth.apiKeyValue ?? "";
+    if (!value && auth.apiKeySecretRef) value = await getSecret(auth.apiKeySecretRef) ?? "";
+    value = interpolate(value, vars);
+    headers[auth.apiKeyName ?? "X-API-Key"] = value;
+  }
+  if (auth.type === "oauth2") {
+    const now = Date.now();
+    if (auth.oauth2CachedToken && auth.oauth2TokenExpiry && auth.oauth2TokenExpiry > now + 5e3) {
+      headers["Authorization"] = `Bearer ${auth.oauth2CachedToken}`;
+    }
+  }
+  return headers;
+}
+async function buildApiKeyParam(auth, vars) {
+  if (auth.type !== "apikey" || auth.apiKeyIn !== "query") return null;
+  let value = auth.apiKeyValue ?? "";
+  if (!value && auth.apiKeySecretRef) value = await getSecret(auth.apiKeySecretRef) ?? "";
+  value = interpolate(value, vars);
+  return { key: auth.apiKeyName ?? "apikey", value };
+}
+function parseDigestChallenge(wwwAuth) {
+  const extract = (key) => {
+    const m = new RegExp(`${key}="([^"]*)"`, "i").exec(wwwAuth);
+    return m ? m[1] : "";
+  };
+  const extractUnquoted = (key) => {
+    const m = new RegExp(`${key}=([^,\\s]+)`, "i").exec(wwwAuth);
+    return m ? m[1] : "";
+  };
+  return {
+    realm: extract("realm"),
+    nonce: extract("nonce"),
+    qop: extract("qop") || extractUnquoted("qop") || void 0,
+    algorithm: extract("algorithm") || extractUnquoted("algorithm") || "MD5",
+    opaque: extract("opaque") || void 0
+  };
+}
+function md5(s) {
+  return crypto.createHash("md5").update(s).digest("hex");
+}
+function buildDigestAuthHeader(challenge, username, password, method, uri) {
+  const { realm, nonce, qop, algorithm, opaque } = challenge;
+  const algo = (algorithm ?? "MD5").toUpperCase();
+  const ha1 = algo === "MD5-SESS" ? md5(`${md5(`${username}:${realm}:${password}`)}:${nonce}:`) : md5(`${username}:${realm}:${password}`);
+  const ha2 = md5(`${method}:${uri}`);
+  let response;
+  let nc;
+  let cnonce;
+  if (qop === "auth" || qop === "auth-int") {
+    nc = "00000001";
+    cnonce = crypto.randomBytes(8).toString("hex");
+    response = md5(`${ha1}:${nonce}:${nc}:${cnonce}:${qop}:${ha2}`);
+  } else {
+    response = md5(`${ha1}:${nonce}:${ha2}`);
+  }
+  let header = `Digest username="${username}", realm="${realm}", nonce="${nonce}", uri="${uri}", response="${response}"`;
+  if (qop) header += `, qop=${qop}`;
+  if (nc) header += `, nc=${nc}`;
+  if (cnonce) header += `, cnonce="${cnonce}"`;
+  if (opaque) header += `, opaque="${opaque}"`;
+  if (algo !== "MD5") header += `, algorithm=${algo}`;
+  return header;
+}
+async function performDigestAuth(url, method, auth, vars, fetchFn) {
+  const probeResp = await fetchFn(url, { method, headers: {} });
+  if (probeResp.status !== 401) return null;
+  const wwwAuth = probeResp.headers.get("www-authenticate") ?? "";
+  if (!wwwAuth.toLowerCase().startsWith("digest")) return null;
+  const challenge = parseDigestChallenge(wwwAuth);
+  let password = auth.password ?? "";
+  if (!password && auth.passwordSecretRef) password = await getSecret(auth.passwordSecretRef) ?? "";
+  password = interpolate(password, vars);
+  const username = interpolate(auth.username ?? "", vars);
+  let uri = "/";
+  try {
+    uri = new URL(url).pathname + (new URL(url).search ?? "");
+  } catch {
+  }
+  return buildDigestAuthHeader(challenge, username, password, method, uri);
+}
+async function performNtlmRequest(_url, _method, _auth, _vars) {
+  throw new Error(
+    'NTLM auth is not yet implemented. Add "httpntlm" to package.json dependencies and implement performNtlmRequest in auth-builder.ts.'
+  );
+}
+async function fetchOAuth2Token(auth, vars) {
+  const flow = auth.oauth2Flow ?? "client_credentials";
+  if (flow === "authorization_code") {
+    throw new Error("authorization_code flow requires the oauth2:startFlow IPC call from the renderer.");
+  }
+  if (flow === "implicit") {
+    throw new Error("implicit flow cannot be performed server-side — tokens must be obtained via the browser redirect.");
+  }
+  const tokenUrl = interpolate(auth.oauth2TokenUrl ?? "", vars);
+  if (!tokenUrl) throw new Error("OAuth 2.0: tokenUrl is required.");
+  const clientId = interpolate(auth.oauth2ClientId ?? "", vars);
+  let clientSecret = auth.oauth2ClientSecret ?? "";
+  if (!clientSecret && auth.oauth2ClientSecretRef) {
+    clientSecret = await getSecret(auth.oauth2ClientSecretRef) ?? "";
+  }
+  clientSecret = interpolate(clientSecret, vars);
+  const params = new URLSearchParams();
+  params.set("grant_type", flow === "password" ? "password" : "client_credentials");
+  params.set("client_id", clientId);
+  params.set("client_secret", clientSecret);
+  if (auth.oauth2Scopes) params.set("scope", auth.oauth2Scopes);
+  if (flow === "password") {
+    let password = auth.password ?? "";
+    if (!password && auth.passwordSecretRef) password = await getSecret(auth.passwordSecretRef) ?? "";
+    password = interpolate(password, vars);
+    params.set("username", interpolate(auth.username ?? "", vars));
+    params.set("password", password);
+  }
+  const { fetch: nodeFetch } = await import("undici");
+  const resp = await nodeFetch(tokenUrl, {
+    method: "POST",
+    headers: { "Content-Type": "application/x-www-form-urlencoded" },
+    body: params.toString()
+  });
+  if (!resp.ok) {
+    const body = await resp.text();
+    throw new Error(`OAuth 2.0 token request failed (${resp.status}): ${body}`);
+  }
+  const json = await resp.json();
+  const accessToken = String(json["access_token"] ?? "");
+  if (!accessToken) throw new Error("OAuth 2.0: token response missing access_token.");
+  const expiresIn = Number(json["expires_in"] ?? 3600);
+  const expiresAt = Date.now() + expiresIn * 1e3;
+  return {
+    accessToken,
+    expiresAt,
+    refreshToken: json["refresh_token"] ? String(json["refresh_token"]) : void 0
+  };
+}
+exports.buildApiKeyParam = buildApiKeyParam;
+exports.buildAuthHeaders = buildAuthHeaders;
+exports.buildDynamicVars = buildDynamicVars;
+exports.buildEnvVars = buildEnvVars;
+exports.buildUrl = buildUrl;
+exports.fetchOAuth2Token = fetchOAuth2Token;
+exports.getSecret = getSecret;
+exports.initSecretStore = initSecretStore;
+exports.interpolate = interpolate;
+exports.mergeVars = mergeVars;
+exports.performDigestAuth = performDigestAuth;
+exports.performNtlmRequest = performNtlmRequest;
+exports.registerSecretHandlers = registerSecretHandlers;

package/out/main/chunks/import-C9qdkBCH.js

@@ -0,0 +1,154 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const uuid = require("uuid");
+const soapHandler = require("./soap-handler-Cpj-JwyA.js");
+require("https");
+require("http");
+require("@xmldom/xmldom");
+const SOAP_11_CONTENT_TYPE = "text/xml; charset=utf-8";
+const SOAP_12_CONTENT_TYPE = "application/soap+xml; charset=utf-8";
+function contentTypeForSoap(version) {
+  return version === "1.2" ? SOAP_12_CONTENT_TYPE : SOAP_11_CONTENT_TYPE;
+}
+function withContentType(headers, value) {
+  const idx = headers.findIndex((h) => h.key.toLowerCase() === "content-type");
+  const next = { key: "Content-Type", value, enabled: true };
+  if (idx === -1) return [...headers, next];
+  return headers.map((h, i) => i === idx ? { ...h, value, enabled: true } : h);
+}
+function buildRequestsFromWsdl(parsed) {
+  const out = [];
+  const byName = /* @__PURE__ */ new Map();
+  for (const op of parsed.operations) {
+    const existing = byName.get(op.name);
+    if (!existing || existing.soapVersion === "1.2" && op.soapVersion === "1.1") byName.set(op.name, op);
+  }
+  for (const op of byName.values()) {
+    const ct = contentTypeForSoap(op.soapVersion);
+    const req = {
+      id: uuid.v4(),
+      name: op.name,
+      method: "POST",
+      url: op.endpoint ?? "",
+      headers: withContentType([], ct),
+      params: [],
+      auth: { type: "none" },
+      protocol: "soap",
+      body: {
+        mode: "soap",
+        soap: {
+          wsdlUrl: "",
+          operationName: op.name,
+          soapAction: op.soapAction ?? "",
+          envelope: op.inputTemplate
+        }
+      },
+      description: op.soapAction ? `SOAPAction: ${op.soapAction}` : void 0
+    };
+    out.push(req);
+  }
+  return out;
+}
+function buildCollectionFromWsdl(name, parsed) {
+  const requests = buildRequestsFromWsdl(parsed);
+  const requestMap = {};
+  for (const r of requests) requestMap[r.id] = r;
+  const collection = {
+    version: "1.0",
+    id: uuid.v4(),
+    name,
+    description: `Imported from WSDL — ${parsed.endpoints[0]?.address ?? parsed.targetNamespace}`,
+    rootFolder: {
+      id: uuid.v4(),
+      name: "root",
+      description: "",
+      folders: [],
+      requestIds: requests.map((r) => r.id)
+    },
+    requests: requestMap
+  };
+  return { collection, requestIds: requests.map((r) => r.id) };
+}
+function pathFromUrl(url) {
+  try {
+    return new URL(url).pathname || "/";
+  } catch {
+    return "/";
+  }
+}
+function pickFreePort(existing) {
+  let p = 3900;
+  while (existing.includes(p)) p++;
+  return p;
+}
+function buildMockFromWsdl(name, parsed, existingPorts = []) {
+  const opMap = {};
+  const seen = /* @__PURE__ */ new Set();
+  for (const op of parsed.operations) {
+    if (seen.has(op.name)) continue;
+    seen.add(op.name);
+    opMap[op.name] = soapHandler.buildResponseEnvelope(op.name, parsed.targetNamespace, op.soapVersion);
+  }
+  const pathsByVersion = /* @__PURE__ */ new Map();
+  for (const ep of parsed.endpoints) {
+    pathsByVersion.set(pathFromUrl(ep.address), ep.soapVersion);
+  }
+  if (pathsByVersion.size === 0) pathsByVersion.set("/", "1.1");
+  const routes = [];
+  for (const [routePath, version] of pathsByVersion.entries()) {
+    routes.push({
+      id: uuid.v4(),
+      method: "POST",
+      path: routePath,
+      statusCode: 200,
+      headers: { "Content-Type": contentTypeForSoap(version) },
+      body: "",
+      description: `SOAP ${version} — dispatched per operation`,
+      script: soapHandler.buildMockDispatchScript(),
+      // Externalized so workspace JSON stays compact: the dispatch script reads
+      // these via the script-runner's `metadata` context binding instead of
+      // baking each envelope as a JS string literal.
+      metadata: { soapEnvelopes: opMap, soapVersion: version }
+    });
+  }
+  return {
+    version: "1.0",
+    id: uuid.v4(),
+    name,
+    port: pickFreePort(existingPorts),
+    routes
+  };
+}
+function importWsdl(wsdlText, opts = {}) {
+  const parsed = soapHandler.parseWsdl(wsdlText);
+  const baseName = opts.name?.trim() || (() => {
+    try {
+      return new URL(parsed.endpoints[0]?.address ?? "").hostname || "WSDL service";
+    } catch {
+      return "WSDL service";
+    }
+  })();
+  const { collection } = buildCollectionFromWsdl(baseName, parsed);
+  const mock = buildMockFromWsdl(`${baseName} (mock)`, parsed, opts.existingMockPorts ?? []);
+  return { parsed, collection, mock };
+}
+function defaultCollectionRelPath(ws, collection) {
+  const safe = collection.name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "") || "wsdl";
+  let i = 0;
+  let candidate = `collections/${safe}.json`;
+  const existing = new Set(ws.collections);
+  while (existing.has(candidate)) {
+    i++;
+    candidate = `collections/${safe}-${i}.json`;
+  }
+  return candidate;
+}
+function defaultMockRelPath(mock) {
+  return `mocks/${mock.id}.mock.json`;
+}
+exports.buildCollectionFromWsdl = buildCollectionFromWsdl;
+exports.buildMockFromWsdl = buildMockFromWsdl;
+exports.buildRequestsFromWsdl = buildRequestsFromWsdl;
+exports.defaultCollectionRelPath = defaultCollectionRelPath;
+exports.defaultMockRelPath = defaultMockRelPath;
+exports.importWsdl = importWsdl;