magnitude-test/dist/version-DtiDJ6_4.js

A TypeScript client for running automated UI tests through the Magnitude testing platform

import pino from 'pino';
import { createRequire } from 'node:module';

const logger = pino({
  level: process.env.MAGNITUDE_LOG_LEVEL || "warn",
  transport: process.stdout.isTTY ? {
    target: "pino-pretty",
    options: {
      colorize: !process.env.NO_COLOR,
      translateTime: "SYS:HH:MM:ss.l",
      ignore: "pid,hostname"
    }
  } : void 0
}).child({
  name: "runner"
});

const IPV4_IN_IPV6_PREFIX = "::f{4}:";
const LOOPBACK_IP_RANGES = [
  // 127.0.0.0 - 127.255.255.255 (IPv4 loopback)
  new RegExp(`^(${IPV4_IN_IPV6_PREFIX})?127\\.\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}`),
  // ::1 (IPv6 loopback)
  /^::1$/
];
const SPECIAL_LOCAL_IPS = ["::1", "::", "0.0.0.0"];
const LOCALHOST_DOMAINS = ["localhost"];
function isLoopbackIp(address) {
  return SPECIAL_LOCAL_IPS.includes(address) || LOOPBACK_IP_RANGES.some((pattern) => pattern.test(address));
}
function extractHostname(urlOrHostname) {
  try {
    if (!urlOrHostname.includes("://")) {
      urlOrHostname = "http://" + urlOrHostname;
    }
    const parsedUrl = new URL(urlOrHostname);
    return parsedUrl.hostname.toLowerCase();
  } catch (error) {
    return urlOrHostname.toLowerCase();
  }
}
function cleanHostname(hostname) {
  return hostname.replace(/^\[|\]$/g, "");
}
function isLocalhostDomain(hostname) {
  const lowerHostname = hostname.toLowerCase();
  return LOCALHOST_DOMAINS.includes(lowerHostname) || lowerHostname.endsWith(".localhost");
}
function isLoopbackHost(urlOrHostname) {
  try {
    const hostname = extractHostname(urlOrHostname);
    if (isLocalhostDomain(hostname)) {
      return true;
    }
    return isLoopbackIp(cleanHostname(hostname));
  } catch (error) {
    console.error("Invalid URL or hostname:", error);
    return false;
  }
}
function isLoopbackUrl(url) {
  return isLoopbackHost(url);
}
function addProtocolIfMissing(url) {
  if (!url.includes("://")) {
    if (isLoopbackUrl(url)) {
      return `http://${url}`;
    } else {
      return `https://${url}`;
    }
  } else {
    return url;
  }
}
function describeModel(client) {
  if (client.model !== "unknown") {
    return `${client.provider}:${client.model}`;
  } else {
    return `${client.provider}`;
  }
}
const knownCostMap = {
  "gemini-2.5-pro": [1.25, 10],
  "gemini-2.5-flash": [0.15, 0.6],
  "claude-3.5-sonnet": [3, 15],
  "claude-3.7-sonnet": [3, 15],
  "gpt-4.1": [2, 8],
  "gpt-4.1-mini": [0.4, 1.6],
  "gpt-4.1-nano": [0.1, 0.4],
  "gpt-4o": [3.75, 15]
};
function processUrl(...urls) {
  if (urls.length === 0) return;
  if (urls.length === 1) return urls[0];
  const [base, relative, ...rest] = urls;
  if (!relative) return processUrl(base, ...rest);
  if (!base) return processUrl(relative, ...rest);
  try {
    return processUrl(new URL(relative).toString(), ...rest);
  } catch {
    try {
      return processUrl(new URL(relative, base).toString(), ...rest);
    } catch (_e) {
      return processUrl(relative, ...rest);
    }
  }
}

const require = createRequire(import.meta.url);
const VERSION = require("../package.json").version;

export { VERSION as V, addProtocolIfMissing as a, describeModel as d, knownCostMap as k, logger as l, processUrl as p };