@osdk/integration-testing 0.0.0 → 0.1.0

package/build/cjs/index.cjs

@@ -0,0 +1,841 @@
+'use strict';
+
+var fs3 = require('fs/promises');
+var client = require('@osdk/client');
+var unitTesting = require('@osdk/unit-testing');
+var undici = require('undici');
+var path4 = require('path');
+var generatorConverters_preview = require('@osdk/generator-converters.preview');
+var invariant4 = require('tiny-invariant');
+var promises = require('timers/promises');
+var child_process = require('child_process');
+var events = require('events');
+var conjureLite = require('conjure-lite');
+var seedHelpers = require('@osdk/seed-helpers');
+var util = require('util');
+var semver = require('semver');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var fs3__namespace = /*#__PURE__*/_interopNamespace(fs3);
+var path4__default = /*#__PURE__*/_interopDefault(path4);
+var invariant4__default = /*#__PURE__*/_interopDefault(invariant4);
+
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+async function createIntegrationClient(config) {
+  const {
+    baseUrl,
+    metadata,
+    caCertPath
+  } = config;
+  const agent = new undici.Agent({
+    connect: caCertPath ? {
+      ca: await fs3__namespace.default.readFile(caCertPath)
+    } : {
+      rejectUnauthorized: false
+    }
+  });
+  const fetchWithCert = (input, init) => undici.fetch(input, {
+    ...init,
+    dispatcher: agent
+  });
+  const realClient = client.createClient(baseUrl, metadata.ontology.rid, () => Promise.resolve("integration-client-token"), {}, fetchWithCert);
+  const mockClient = unitTesting.createMockClient();
+  const clientInternal = (def) => {
+    switch (def.type) {
+      case "query":
+        return mockClient(def);
+      case "action":
+        return realClient(def);
+      case "interface":
+        return realClient(def);
+      case "object":
+        return realClient(def);
+      case "experiment":
+      default:
+        return realClient(def);
+    }
+  };
+  const client$1 = Object.defineProperties(clientInternal, {
+    ...Object.getOwnPropertyDescriptors(realClient),
+    whenQuery: {
+      value: mockClient.whenQuery.bind(void 0)
+    },
+    clearStubs: {
+      value: mockClient.clearStubs.bind(void 0)
+    }
+  });
+  return client$1;
+}
+var MAX_CAPTURED_STDERR_CHUNKS = 32;
+var DEFAULT_READY_TIMEOUT_MS = 3e4;
+var DEFAULT_STOP_GRACE_MS = 5e3;
+var TERMINAL_STATES = /* @__PURE__ */ new Set(["FAILED", "STOPPED"]);
+var FoundryCliService = class {
+  #foundryCliPath;
+  #projectPath;
+  #child;
+  #context;
+  #stderr = [];
+  #exit;
+  constructor(name, config) {
+    this.name = name;
+    this.dependencies = config.dependencies ?? [];
+    this.#foundryCliPath = config.foundryCliPath ?? "foundry";
+    this.#projectPath = config.projectPath;
+  }
+  getProjectPath() {
+    return this.#projectPath;
+  }
+  getCaCertPath() {
+    return this.#context?.discoverer.get(this.name)?.caCertPath ?? void 0;
+  }
+  getUrl() {
+    return this.#context?.discoverer.get(this.name)?.url;
+  }
+  getExitInfo() {
+    if (this.#exit === void 0) {
+      return void 0;
+    }
+    const {
+      code,
+      signal
+    } = this.#exit;
+    return signal ?? `code ${code}`;
+  }
+  getCapturedStderr() {
+    return this.#stderr.join("").trim();
+  }
+  getContext() {
+    const context = this.#context;
+    !(context !== void 0) ? process.env.NODE_ENV !== "production" ? invariant4__default.default(false, `${this.name} is not registered with a CliServiceLauncher, so it has no discoverer or status server to consult`) : invariant4__default.default(false) : void 0;
+    return context;
+  }
+  attach(context) {
+    this.#context = context;
+  }
+  async start() {
+    if (this.#child !== void 0) {
+      return;
+    }
+    await this.getContext().discoverer.refresh();
+    !!(await this.checkHealth()).ready ? process.env.NODE_ENV !== "production" ? invariant4__default.default(false, `${this.name} is already running; stop it before starting a new one`) : invariant4__default.default(false) : void 0;
+    await this.#spawn();
+  }
+  async #spawn() {
+    this.#exit = void 0;
+    this.#stderr = [];
+    const child = child_process.spawn(this.#foundryCliPath, [...this.getArgs()], {
+      cwd: this.#projectPath
+    });
+    this.#child = child;
+    child.stderr.setEncoding("utf-8");
+    child.stderr.on("data", (chunk) => {
+      if (this.#stderr.push(chunk) > MAX_CAPTURED_STDERR_CHUNKS) {
+        this.#stderr.shift();
+      }
+    });
+    child.stdout.resume();
+    child.on("exit", (code, signal) => {
+      this.#exit = {
+        code,
+        signal
+      };
+    });
+    await new Promise((resolve2, reject) => {
+      child.once("spawn", resolve2);
+      child.once("error", (error) => reject(new Error(`Failed to spawn ${this.name} via ${this.#foundryCliPath}`, {
+        cause: error
+      })));
+    });
+  }
+  async checkHealth() {
+    const {
+      discoverer,
+      statusServer
+    } = this.getContext();
+    const discovery = discoverer.get(this.name);
+    if (typeof discovery === "undefined") {
+      return {
+        service: this.name,
+        state: "UNDISCOVERED",
+        ready: false,
+        terminal: false
+      };
+    }
+    const status = await statusServer.getServiceStatus(this.name);
+    const state = status?.status ?? "DISCOVERED";
+    return {
+      service: this.name,
+      state,
+      ready: state === "READY",
+      terminal: TERMINAL_STATES.has(state),
+      url: discovery.url,
+      ...status?.message != null ? {
+        message: status.message
+      } : {}
+    };
+  }
+  /**
+   * Signal the service and wait for the process to actually be gone.
+   */
+  async stop() {
+    const child = this.#child;
+    this.#child = void 0;
+    if (child === void 0 || child.exitCode != null || child.signalCode != null) {
+      return;
+    }
+    const exited = events.once(child, "exit");
+    child.kill("SIGINT");
+    const escalation = setTimeout(() => {
+      child.kill("SIGKILL");
+    }, DEFAULT_STOP_GRACE_MS);
+    try {
+      await exited;
+    } finally {
+      clearTimeout(escalation);
+    }
+  }
+};
+
+// src/utils/process.ts
+var isProcessAlive = (pid) => {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    return err.code === "EPERM";
+  }
+};
+
+// src/utils/service.ts
+var SERVICE_FILE_NAMES = {
+  ONTOLOGY: "ontology",
+  TYPESCRIPT_FUNCTIONS: "typescript-functions",
+  PYTHON_FUNCTIONS: "python-functions",
+  APP: "app",
+  STATUS_SERVER: "status-server",
+  PLATFORM_API_PROXY: "platform-api-proxy"
+};
+var SERVICE_NAMES_BY_FILE_NAME = new Map(Object.entries(SERVICE_FILE_NAMES).map(([name, stem]) => [stem, name]));
+var serviceNameFromFileName = (fileName) => {
+  const name = fileName.match(/^\.?(?<name>.+)-discovery\.json$/u)?.groups?.name;
+  return name === void 0 ? void 0 : SERVICE_NAMES_BY_FILE_NAME.get(name);
+};
+
+// src/cli-service/ServiceDiscoverer.ts
+var ServiceDiscoverer = class {
+  #basePath;
+  #discovered = /* @__PURE__ */ new Map();
+  constructor(args) {
+    this.#basePath = args.basePath;
+  }
+  get discoveryDir() {
+    return this.#basePath;
+  }
+  async start() {
+    await fs3__namespace.mkdir(this.#basePath, {
+      recursive: true
+    });
+    await this.refresh();
+  }
+  /**
+   * Re-read every discovery file in the directory.
+   */
+  async refresh() {
+    const fileNames = await fs3__namespace.readdir(this.#basePath);
+    const discoveries = await Promise.all(fileNames.map((fileName) => this.#read(fileName)));
+    return discoveries.filter((discovery) => discovery !== void 0);
+  }
+  get(name) {
+    const discovery = this.#discovered.get(name);
+    if (typeof discovery === "undefined") {
+      return void 0;
+    }
+    if (!isProcessAlive(discovery.pid)) {
+      this.#discovered.delete(name);
+      return void 0;
+    }
+    return discovery;
+  }
+  isDiscovered(name) {
+    return this.get(name) !== void 0;
+  }
+  all() {
+    const live = /* @__PURE__ */ new Map();
+    for (const name of this.#discovered.keys()) {
+      const discovery = this.get(name);
+      if (discovery !== void 0) {
+        live.set(name, discovery);
+      }
+    }
+    return live;
+  }
+  stop() {
+    this.#discovered.clear();
+  }
+  async #read(fileName) {
+    const serviceName = serviceNameFromFileName(fileName);
+    if (typeof serviceName === "undefined") {
+      return void 0;
+    }
+    let contents;
+    try {
+      contents = await fs3__namespace.readFile(path4.join(this.#basePath, fileName), "utf-8");
+    } catch {
+      this.#discovered.delete(serviceName);
+      return void 0;
+    }
+    let parsed;
+    try {
+      parsed = JSON.parse(contents);
+    } catch {
+      return void 0;
+    }
+    !parsed.url ? process.env.NODE_ENV !== "production" ? invariant4__default.default(false, `Service URL not found`) : invariant4__default.default(false) : void 0;
+    this.#discovered.set(serviceName, parsed);
+    return parsed;
+  }
+};
+
+// src/generated/cli/OntologySeedingService.ts
+var OntologySeedingService_exports = {};
+__export(OntologySeedingService_exports, {
+  setSeed: () => setSeed
+});
+async function setSeed(ctx, seed) {
+  return conjureLite.conjureFetch(ctx, `/seed`, "PUT", seed);
+}
+
+// src/generated/cli/StatusService.ts
+var StatusService_exports = {};
+__export(StatusService_exports, {
+  getStatus: () => getStatus,
+  publishStatus: () => publishStatus
+});
+async function publishStatus(ctx, status) {
+  return conjureLite.conjureFetch(ctx, `/status`, "POST", status);
+}
+async function getStatus(ctx) {
+  return conjureLite.conjureFetch(ctx, `/status`, "GET");
+}
+
+// src/cli-service/StatusServer.ts
+var HEALTH_REQUEST_TIMEOUT_MS = 2e3;
+var StatusServer = class extends FoundryCliService {
+  /** Shared by callers that ask while a fetch is already outstanding. */
+  #inFlight;
+  constructor(config) {
+    super("STATUS_SERVER", config);
+  }
+  getArgs() {
+    return ["start", "status-server", "--discovery-path", path4__default.default.resolve(this.getProjectPath(), ".palantir")];
+  }
+  async checkHealth() {
+    const discovery = this.getContext().discoverer.get("STATUS_SERVER");
+    if (discovery === void 0) {
+      return {
+        service: "STATUS_SERVER",
+        state: "UNDISCOVERED",
+        ready: false,
+        terminal: false
+      };
+    }
+    const healthy = await this.#isHealthy(discovery.url);
+    return {
+      service: "STATUS_SERVER",
+      state: healthy ? "READY" : "DISCOVERED",
+      ready: healthy,
+      terminal: false,
+      url: discovery.url
+    };
+  }
+  async #isHealthy(baseUrl) {
+    try {
+      const response = await fetch(new URL("/api/health", baseUrl), {
+        signal: AbortSignal.timeout(HEALTH_REQUEST_TIMEOUT_MS)
+      });
+      if (!response.ok) {
+        return false;
+      }
+      const body = await response.json();
+      return body.status === "healthy";
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * The lifecycle snapshot for every service.
+   */
+  async getServiceStatuses() {
+    const baseUrl = this.getContext().discoverer.get("STATUS_SERVER")?.url;
+    !baseUrl ? process.env.NODE_ENV !== "production" ? invariant4__default.default(false, "Cannot get service status because the status server is not discovered yet") : invariant4__default.default(false) : void 0;
+    this.#inFlight ??= StatusService_exports.getStatus({
+      baseUrl,
+      servicePath: ""
+    }).catch(() => void 0).finally(() => {
+      this.#inFlight = void 0;
+    });
+    const result = await this.#inFlight;
+    return result ?? [];
+  }
+  async getServiceStatus(name) {
+    const statuses = await this.getServiceStatuses();
+    return statuses.find(({
+      service
+    }) => service === name);
+  }
+};
+
+// src/cli-service/CliServiceLauncher.ts
+var HEALTH_POLL_INTERVAL_MS = 200;
+var CliServiceLauncher = class {
+  #discoverer;
+  #statusServer;
+  #services = /* @__PURE__ */ new Map();
+  /** Memoized in-flight starts, so a shared dependency is started once. */
+  #starts = /* @__PURE__ */ new Map();
+  #started = false;
+  constructor(config = {}) {
+    const projectDir = config.projectDir ?? process.cwd();
+    this.#discoverer = new ServiceDiscoverer({
+      basePath: path4__default.default.resolve(projectDir, ".palantir")
+    });
+    this.#statusServer = config.statusServer ?? new StatusServer({
+      projectPath: projectDir,
+      foundryCliPath: config.foundryCliPath
+    });
+    this.register(this.#statusServer);
+  }
+  get services() {
+    return [...this.#services.values()];
+  }
+  get(name) {
+    return this.#services.get(name);
+  }
+  register(service) {
+    const existing = this.#services.get(service.name);
+    if (existing === service) {
+      return service;
+    }
+    !(existing === void 0) ? process.env.NODE_ENV !== "production" ? invariant4__default.default(false, `A different ${service.name} service is already registered`) : invariant4__default.default(false) : void 0;
+    this.#services.set(service.name, service);
+    service.attach({
+      discoverer: this.#discoverer,
+      statusServer: this.#statusServer
+    });
+    for (const dependency of service.dependencies) {
+      this.register(dependency);
+    }
+    return service;
+  }
+  async start() {
+    await this.#ensureDiscovering();
+    this.#assertAcyclic();
+    const results = await Promise.allSettled([...this.#services.values()].map((service) => this.#start(service)));
+    const failed = results.find((result) => result.status === "rejected");
+    if (failed !== void 0) {
+      await this.stop();
+      throw failed.reason;
+    }
+  }
+  async startService(service) {
+    this.register(service);
+    await this.#ensureDiscovering();
+    this.#assertAcyclic();
+    await this.#start(service);
+  }
+  async #ensureDiscovering() {
+    if (!this.#started) {
+      await this.#discoverer.start();
+      this.#started = true;
+    }
+  }
+  async #start(service) {
+    const runningPromise = this.#starts.get(service.name);
+    if (typeof runningPromise !== "undefined") {
+      return runningPromise;
+    }
+    const started = this.#startImmediate(service);
+    this.#starts.set(service.name, started);
+    try {
+      await started;
+    } catch (err) {
+      this.#starts.delete(service.name);
+      throw err;
+    }
+  }
+  async #startImmediate(service) {
+    await Promise.all(this.#prerequisites(service).map((dependency) => this.#start(dependency)));
+    await service.start();
+    await this.waitUntilReady(service);
+  }
+  /**
+   * Everything that must be ready before `service` may start: its declared
+   * dependencies, plus the status server.
+   */
+  #prerequisites(service) {
+    return service.name === this.#statusServer.name ? service.dependencies : [this.#statusServer, ...service.dependencies];
+  }
+  /**
+   * Poll a service's health until it is ready, reaches a terminal state, or
+   * exceeds its timeout.
+   */
+  async waitUntilReady(service) {
+    const deadline = Date.now() + DEFAULT_READY_TIMEOUT_MS;
+    let health = await service.checkHealth();
+    while (!health.ready) {
+      const current = health;
+      const notReady = () => `${service.name} is not ready (${current.state})${formatError(service, current)}`;
+      !!current.terminal ? process.env.NODE_ENV !== "production" ? invariant4__default.default(false, notReady) : invariant4__default.default(false) : void 0;
+      !(service.getExitInfo() === void 0) ? process.env.NODE_ENV !== "production" ? invariant4__default.default(false, notReady) : invariant4__default.default(false) : void 0;
+      !(Date.now() < deadline) ? process.env.NODE_ENV !== "production" ? invariant4__default.default(false, () => `${service.name} is not ready (${current.state}) within ${DEFAULT_READY_TIMEOUT_MS}ms${formatError(service, current)}`) : invariant4__default.default(false) : void 0;
+      await promises.setTimeout(HEALTH_POLL_INTERVAL_MS);
+      await this.#discoverer.refresh();
+      health = await service.checkHealth();
+    }
+    return health;
+  }
+  async checkHealth() {
+    await this.#discoverer.refresh();
+    return Promise.all([...this.#services.values()].map((service) => service.checkHealth()));
+  }
+  async checkDependencies(service) {
+    await this.#discoverer.refresh();
+    return Promise.all(service.dependencies.map((dependency) => dependency.checkHealth()));
+  }
+  async dependenciesReady(service) {
+    const healths = await this.checkDependencies(service);
+    return healths.every(({
+      ready
+    }) => ready);
+  }
+  /**
+   * Stop every service, dependents before their dependencies, waiting for each
+   * process to be gone before the next is signalled.
+   */
+  async stop() {
+    for (const service of this.#startupOrder().reverse()) {
+      await service.stop();
+    }
+    this.#starts.clear();
+    this.#discoverer.stop();
+    this.#started = false;
+  }
+  /**
+   * Registered services in a valid startup order: every service appears after
+   * everything it depends on.
+   */
+  #startupOrder() {
+    const ordered = [];
+    const seen = /* @__PURE__ */ new Set();
+    const visit = (service) => {
+      if (seen.has(service.name)) {
+        return;
+      }
+      seen.add(service.name);
+      for (const dependency of this.#prerequisites(service)) {
+        visit(dependency);
+      }
+      ordered.push(service);
+    };
+    for (const service of this.#services.values()) {
+      visit(service);
+    }
+    return ordered;
+  }
+  #assertAcyclic() {
+    const settled = /* @__PURE__ */ new Set();
+    const visit = (service, walkedPath) => {
+      if (settled.has(service.name)) {
+        return;
+      }
+      const cycleStart = walkedPath.indexOf(service.name);
+      !(cycleStart === -1) ? process.env.NODE_ENV !== "production" ? invariant4__default.default(false, () => `Dependency cycle between services: ${[...walkedPath.slice(cycleStart), service.name].join(" -> ")}`) : invariant4__default.default(false) : void 0;
+      for (const dependency of this.#prerequisites(service)) {
+        visit(dependency, [...walkedPath, service.name]);
+      }
+      settled.add(service.name);
+    };
+    for (const service of this.#services.values()) {
+      visit(service, []);
+    }
+  }
+};
+var formatError = (service, health) => {
+  const parts = [];
+  if (health.message != null && health.message.length > 0) {
+    parts.push(health.message);
+  }
+  const exit = service.getExitInfo();
+  if (exit !== void 0) {
+    parts.push(`the process exited (${exit})`);
+  }
+  const stderr = service.getCapturedStderr();
+  if (stderr.length > 0) {
+    parts.push(`stderr:
+${stderr}`);
+  }
+  return parts.length === 0 ? "" : `: ${parts.join("; ")}`;
+};
+var OntologyServer = class extends FoundryCliService {
+  #metadataPath;
+  constructor(config) {
+    super("ONTOLOGY", config);
+    this.#metadataPath = path4.isAbsolute(config.metadataPath) ? config.metadataPath : path4.resolve(config.projectPath, config.metadataPath);
+  }
+  getMetadataPath() {
+    return this.#metadataPath;
+  }
+  getArgs() {
+    return ["start", "ontology", "--skip-build", "--metadata", this.#metadataPath, "--discovery-path", path4__default.default.resolve(this.getProjectPath(), ".palantir")];
+  }
+};
+function createSeedClient(config) {
+  const {
+    baseUrl,
+    metadata,
+    fetchFn
+  } = config;
+  const builder = new seedHelpers.SeedBuilder(metadata);
+  const seedClientFunction = async (seed) => {
+    let result;
+    if (typeof seed === "function") {
+      result = seed(builder);
+    } else {
+      builder.addAll(seed);
+    }
+    await applySeed(builder.build());
+    return result;
+  };
+  const applySeed = async (seed) => {
+    const res = await OntologySeedingService_exports.setSeed({
+      baseUrl,
+      servicePath: "/api",
+      fetchFn
+    }, seed);
+    return res;
+  };
+  const seedClientUtils = {
+    ref: (o, pk) => builder.ref(o, pk),
+    addAll: async (output) => {
+      builder.addAll(output);
+      await applySeed(builder.build());
+    },
+    set: async (output) => {
+      builder.set(output);
+      await applySeed(builder.build());
+    },
+    create: async (o, props) => {
+      const ref = builder.create(o, props);
+      await applySeed(builder.build());
+      return ref;
+    },
+    update: async (ref, props) => {
+      const returnedRef = builder.update(ref, props);
+      await applySeed(builder.build());
+      return returnedRef;
+    },
+    delete: async (ref) => {
+      builder.delete(ref);
+      await applySeed(builder.build());
+    },
+    link: async (source, apiName, target) => {
+      builder.link(source, apiName, target);
+      await applySeed(builder.build());
+    },
+    unlink: async (source, apiName, target) => {
+      builder.unlink(source, apiName, target);
+      await applySeed(builder.build());
+    }
+  };
+  return Object.defineProperties(seedClientFunction, Object.getOwnPropertyDescriptors(seedClientUtils));
+}
+
+// src/utils/empty-ontology-block.ts
+var EMPTY_ONTOLOGY_BLOCK_DATA = {
+  objectTypes: {},
+  sharedPropertyTypes: {},
+  interfaceTypes: {},
+  linkTypes: {},
+  actionTypes: {},
+  blockPermissionInformation: {
+    actionTypes: {},
+    objectTypes: {},
+    linkTypes: {},
+    interfaceTypes: {},
+    sharedPropertyTypes: {}
+  },
+  blockOutputCompassLocations: {},
+  knownIdentifiers: {
+    actionParameterIds: {},
+    actionParameters: {},
+    actionTypes: {},
+    datasourceColumns: {},
+    datasources: {},
+    filesDatasources: {},
+    functions: {},
+    geotimeSeriesSyncs: {},
+    groupIds: {},
+    interfaceActionTypeConstraints: {},
+    interfaceLinkTypes: {},
+    interfaceParameterConstraints: {},
+    interfacePropertyTypes: {},
+    interfaceTypes: {},
+    linkTypeIds: {},
+    linkTypes: {},
+    markings: {},
+    objectTypeIds: {},
+    objectTypes: {},
+    propertyTypeIds: {},
+    propertyTypes: {},
+    sharedPropertyTypes: {},
+    timeSeriesSyncs: {},
+    valueTypes: {},
+    webhooks: {},
+    workshopModules: {}
+  },
+  ruleSets: {}
+};
+
+// src/createIntegrationServer.ts
+var transformMetadata = (metadata) => {
+  const transformed = generatorConverters_preview.PreviewOntologyIrConverter.getPreviewFullMetadataFromBlockData(EMPTY_ONTOLOGY_BLOCK_DATA, metadata);
+  return {
+    ...transformed,
+    ontology: metadata.ontology
+  };
+};
+var writeMetadata = async (args) => {
+  const {
+    metadataPath,
+    previewMetadata
+  } = args;
+  const stringified = JSON.stringify(previewMetadata);
+  await fs3__namespace.default.writeFile(metadataPath, stringified);
+};
+async function createIntegrationServer(config) {
+  const {
+    metadata,
+    projectPath = process.cwd(),
+    foundryCliPath
+  } = config;
+  const testPath = await fs3__namespace.default.mkdtemp(path4__default.default.join(projectPath, ".test-run-"));
+  const metadataPath = path4__default.default.resolve(testPath, "ontology-metadata.json");
+  const previewMetadata = transformMetadata(metadata);
+  const serviceLauncher = new CliServiceLauncher({
+    projectDir: testPath,
+    foundryCliPath
+  });
+  await writeMetadata({
+    previewMetadata,
+    metadataPath
+  });
+  const ontology = serviceLauncher.register(new OntologyServer({
+    projectPath: testPath,
+    metadataPath,
+    foundryCliPath
+  }));
+  let client;
+  let seedClient;
+  return {
+    getOntologyUrl: () => ontology.getUrl(),
+    start: async () => {
+      await serviceLauncher.start();
+    },
+    stop: async () => {
+      await serviceLauncher.stop();
+      await fs3__namespace.default.rm(testPath, {
+        recursive: true,
+        force: true
+      });
+    },
+    getSeedClient: async () => {
+      if (seedClient !== void 0) return seedClient;
+      const baseUrl = ontology.getUrl();
+      !baseUrl ? process.env.NODE_ENV !== "production" ? invariant4__default.default(false, "Ontology server is not ready") : invariant4__default.default(false) : void 0;
+      const caCertPath = ontology.getCaCertPath();
+      !caCertPath ? process.env.NODE_ENV !== "production" ? invariant4__default.default(false, "Ontology server is not ready") : invariant4__default.default(false) : void 0;
+      const agent = new undici.Agent({
+        connect: caCertPath ? {
+          ca: await fs3__namespace.default.readFile(caCertPath)
+        } : {
+          rejectUnauthorized: false
+        }
+      });
+      const fetchWithCert = (input, init) => undici.fetch(input, {
+        ...init,
+        dispatcher: agent
+      });
+      return seedClient = createSeedClient({
+        baseUrl,
+        metadata,
+        fetchFn: fetchWithCert
+      });
+    },
+    getClient: async () => {
+      if (client !== void 0) return client;
+      const baseUrl = ontology.getUrl();
+      !baseUrl ? process.env.NODE_ENV !== "production" ? invariant4__default.default(false, "Ontology server is not ready") : invariant4__default.default(false) : void 0;
+      return client = await createIntegrationClient({
+        baseUrl,
+        metadata,
+        caCertPath: ontology.getCaCertPath()
+      });
+    }
+  };
+}
+var MIN_FOUNDRY_CLI_VERSION = "0.224.0";
+var FOUNDRY_VERSION_PATTERN = /cli (\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?)/u;
+var parseFoundryVersion = (stdout) => stdout.trim().match(FOUNDRY_VERSION_PATTERN)?.[1];
+var versionIsAtMinimum = (version, min) => semver.valid(version) != null && semver.valid(min) != null && semver.gte(version, min);
+var execAsync = util.promisify(child_process.exec);
+var checkFoundryCliVersion = () => {
+  return execAsync("which foundry").then(() => execAsync("foundry --version")).then(({
+    stdout
+  }) => {
+    const version = parseFoundryVersion(stdout);
+    if (!version) return {
+      type: "version-error"
+    };
+    const isMin = versionIsAtMinimum(version, MIN_FOUNDRY_CLI_VERSION);
+    if (!isMin) return {
+      type: "version-incompatible",
+      version
+    };
+    return {
+      type: "installed",
+      version
+    };
+  }).catch(() => ({
+    type: "not-found"
+  }));
+};
+
+exports.checkFoundryCliVersion = checkFoundryCliVersion;
+exports.createIntegrationClient = createIntegrationClient;
+exports.createIntegrationServer = createIntegrationServer;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map