@bgord/bun 1.6.7 → 1.7.0

package/src/json-file-reader-bun.adapter.ts

@@ -1,8 +0,0 @@
-import type * as tools from "@bgord/tools";
-import type { JsonFileReaderPort } from "./json-file-reader.port";
-
-export class JsonFileReaderBunAdapter implements JsonFileReaderPort {
-  async read(path: tools.FilePathRelative | tools.FilePathAbsolute | string): Promise<Record<string, any>> {
-    return Bun.file(typeof path === "string" ? path : path.get()).json();
-  }
-}

package/src/json-file-reader-noop.adapter.ts

@@ -1,10 +0,0 @@
-import type * as tools from "@bgord/tools";
-import type { JsonFileReaderPort } from "./json-file-reader.port";
-
-export class JsonFileReaderNoopAdapter implements JsonFileReaderPort {
-  constructor(private readonly json: Record<string, any>) {}
-
-  async read(_path: tools.FilePathRelative | tools.FilePathAbsolute | string): Promise<Record<string, any>> {
-    return this.json;
-  }
-}

package/src/json-file-reader.port.ts

@@ -1,5 +0,0 @@
-import type * as tools from "@bgord/tools";
-
-export interface JsonFileReaderPort {
-  read(path: tools.FilePathRelative | tools.FilePathAbsolute | string): Promise<Record<string, any>>;
-}

package/src/prerequisites/binary.ts

@@ -1,33 +0,0 @@
-import * as tools from "@bgord/tools";
-import type { BinaryType } from "../binary.vo";
-import type { ClockPort } from "../clock.port";
-import * as prereqs from "../prerequisites.service";
-
-export class PrerequisiteBinary implements prereqs.Prerequisite {
-  readonly kind = "binary";
-  readonly label: prereqs.PrerequisiteLabelType;
-  readonly enabled?: boolean = true;
-
-  private readonly binary: BinaryType;
-
-  constructor(config: prereqs.PrerequisiteConfigType & { binary: BinaryType }) {
-    this.label = config.label;
-    this.enabled = config.enabled === undefined ? true : config.enabled;
-    this.binary = config.binary;
-  }
-
-  async verify(clock: ClockPort): Promise<prereqs.VerifyOutcome> {
-    const stopwatch = new tools.Stopwatch(clock.now());
-
-    try {
-      if (!this.enabled) return prereqs.Verification.undetermined(stopwatch.stop());
-
-      const result = Bun.which(this.binary);
-
-      if (result) return prereqs.Verification.success(stopwatch.stop());
-      return prereqs.Verification.failure(stopwatch.stop());
-    } catch (error) {
-      return prereqs.Verification.failure(stopwatch.stop(), error as Error);
-    }
-  }
-}

package/src/prerequisites/bun.ts

@@ -1,38 +0,0 @@
-import * as tools from "@bgord/tools";
-import type { ClockPort } from "../clock.port";
-import * as prereqs from "../prerequisites.service";
-
-export class PrerequisiteBun implements prereqs.Prerequisite {
-  readonly kind = "bun";
-  readonly label: prereqs.PrerequisiteLabelType;
-  readonly enabled?: boolean = true;
-
-  private readonly version: tools.PackageVersion;
-  private readonly current: string;
-
-  constructor(config: prereqs.PrerequisiteConfigType & { version: tools.PackageVersion; current: string }) {
-    this.label = config.label;
-    this.enabled = config.enabled === undefined ? true : config.enabled;
-    this.version = config.version;
-    this.current = config.current;
-  }
-
-  async verify(clock: ClockPort): Promise<prereqs.VerifyOutcome> {
-    const stopwatch = new tools.Stopwatch(clock.now());
-
-    if (!this.enabled) return prereqs.Verification.undetermined(stopwatch.stop());
-
-    try {
-      const current = tools.PackageVersion.fromString(this.current);
-
-      if (current.isGreaterThanOrEqual(this.version)) return prereqs.Verification.success(stopwatch.stop());
-      return prereqs.Verification.failure(stopwatch.stop(), {
-        message: `Version: ${this.version.toString()}`,
-      });
-    } catch {
-      return prereqs.Verification.failure(stopwatch.stop(), {
-        message: `Invalid version passed: ${this.current}`,
-      });
-    }
-  }
-}

package/src/prerequisites/clock-drift.ts

@@ -1,51 +0,0 @@
-import * as tools from "@bgord/tools";
-import type { ClockPort } from "../clock.port";
-import * as prereqs from "../prerequisites.service";
-import type { TimekeeperPort } from "../timekeeper.port";
-import { TimekeeperGoogleAdapter } from "../timekeeper-google.adapter";
-import { Timeout } from "../timeout.service";
-
-type Dependencies = { Timekeeper?: TimekeeperPort };
-
-export class PrerequisiteClockDrift implements prereqs.Prerequisite {
-  readonly kind = "clock-drift";
-  readonly label: prereqs.PrerequisiteLabelType;
-  readonly enabled?: boolean = true;
-
-  readonly skew: tools.Duration;
-  readonly timeout: tools.Duration;
-
-  constructor(
-    config: prereqs.PrerequisiteConfigType & { skew: tools.Duration; timeout?: tools.Duration },
-    private readonly deps?: Dependencies,
-  ) {
-    this.label = config.label;
-    this.enabled = config.enabled === undefined ? true : config.enabled;
-
-    this.skew = config.skew;
-    this.timeout = config.timeout ?? tools.Duration.Seconds(2);
-  }
-
-  async verify(clock: ClockPort): Promise<prereqs.VerifyOutcome> {
-    const Timekeeper = this.deps?.Timekeeper ?? new TimekeeperGoogleAdapter();
-
-    const stopwatch = new tools.Stopwatch(clock.now());
-
-    if (!this.enabled) return prereqs.Verification.undetermined(stopwatch.stop());
-
-    try {
-      const timestamp = await Timeout.cancellable(
-        (signal: AbortSignal) => Timekeeper.get(signal),
-        this.timeout,
-      );
-      if (!timestamp) return prereqs.Verification.undetermined(stopwatch.stop());
-
-      const duration = clock.now().difference(timestamp).toAbsolute();
-
-      if (duration.isShorterThan(this.skew)) return prereqs.Verification.success(stopwatch.stop());
-      return prereqs.Verification.failure(stopwatch.stop(), { message: `Difference: ${duration.seconds}s` });
-    } catch (error) {
-      return prereqs.Verification.undetermined(stopwatch.stop());
-    }
-  }
-}

package/src/prerequisites/dependency-vulnerabilities.ts

@@ -1,49 +0,0 @@
-import bun from "bun";
-import * as tools from "@bgord/tools";
-import type { ClockPort } from "../clock.port";
-import * as prereqs from "../prerequisites.service";
-
-type BunAuditOutput = { [packageName: string]: { severity: "low" | "moderate" | "high" | "critical" }[] };
-
-export class PrerequisiteDependencyVulnerabilities implements prereqs.Prerequisite {
-  readonly kind = "dependency-vulnerabilities";
-  readonly label: prereqs.PrerequisiteLabelType;
-  readonly enabled?: boolean = true;
-
-  constructor(config: prereqs.PrerequisiteConfigType) {
-    this.label = config.label;
-    this.enabled = config.enabled === undefined ? true : config.enabled;
-  }
-
-  async verify(clock: ClockPort): Promise<prereqs.VerifyOutcome> {
-    const stopwatch = new tools.Stopwatch(clock.now());
-
-    if (!this.enabled) return prereqs.Verification.undetermined(stopwatch.stop());
-
-    try {
-      const command = await bun.$`bun audit --json`.quiet();
-
-      if (command.exitCode !== 0)
-        return prereqs.Verification.failure(stopwatch.stop(), { message: "Audit failure" });
-
-      const audit = JSON.parse(command.stdout.toString()) as BunAuditOutput;
-
-      const criticalVulnerabilitiesCount = Object.values(audit).filter((name) =>
-        name.some((vulnerability) => vulnerability.severity === "critical"),
-      ).length;
-
-      const highVulnerabilitiesCount = Object.values(audit).filter((name) =>
-        name.some((vulnerability) => vulnerability.severity === "high"),
-      ).length;
-
-      if (criticalVulnerabilitiesCount > 0 || highVulnerabilitiesCount > 0)
-        return prereqs.Verification.failure(stopwatch.stop(), {
-          message: `Critical: ${criticalVulnerabilitiesCount} and high: ${highVulnerabilitiesCount}`,
-        });
-
-      return prereqs.Verification.success(stopwatch.stop());
-    } catch (error) {
-      return prereqs.Verification.failure(stopwatch.stop(), error as Error);
-    }
-  }
-}

package/src/prerequisites/directory.ts

@@ -1,70 +0,0 @@
-import { access, constants, stat } from "node:fs/promises";
-import * as tools from "@bgord/tools";
-import type { ClockPort } from "../clock.port";
-import * as prereqs from "../prerequisites.service";
-
-export type PrerequisiteDirectoryPermissionsType = { read?: boolean; write?: boolean; execute?: boolean };
-
-export class PrerequisiteDirectory implements prereqs.Prerequisite {
-  readonly kind = "directory";
-  readonly label: prereqs.PrerequisiteLabelType;
-  readonly enabled?: boolean = true;
-
-  private readonly directory: tools.DirectoryPathAbsoluteType | tools.DirectoryPathRelativeType;
-  private readonly permissions: PrerequisiteDirectoryPermissionsType;
-
-  constructor(
-    config: prereqs.PrerequisiteConfigType & {
-      directory: tools.DirectoryPathAbsoluteType | tools.DirectoryPathRelativeType;
-      permissions?: PrerequisiteDirectoryPermissionsType;
-    },
-  ) {
-    this.label = config.label;
-    this.enabled = config.enabled === undefined ? true : config.enabled;
-
-    this.directory = config.directory;
-    this.permissions = config.permissions ?? {};
-  }
-
-  async verify(clock: ClockPort): Promise<prereqs.VerifyOutcome> {
-    const stopwatch = new tools.Stopwatch(clock.now());
-
-    if (!this.enabled) return prereqs.Verification.undetermined(stopwatch.stop());
-
-    try {
-      const stats = await stat(this.directory);
-
-      if (!stats.isDirectory()) {
-        return prereqs.Verification.failure(stopwatch.stop(), { message: "Not a directory" });
-      }
-    } catch {
-      return prereqs.Verification.failure(stopwatch.stop(), { message: "Directory does not exist" });
-    }
-
-    if (this.permissions.read) {
-      try {
-        await access(this.directory, constants.R_OK);
-      } catch {
-        return prereqs.Verification.failure(stopwatch.stop(), { message: "Directory is not readable" });
-      }
-    }
-
-    if (this.permissions.write) {
-      try {
-        await access(this.directory, constants.W_OK);
-      } catch {
-        return prereqs.Verification.failure(stopwatch.stop(), { message: "Directory is not writable" });
-      }
-    }
-
-    if (this.permissions.execute) {
-      try {
-        await access(this.directory, constants.X_OK);
-      } catch {
-        return prereqs.Verification.failure(stopwatch.stop(), { message: "Directory is not executable" });
-      }
-    }
-
-    return prereqs.Verification.success(stopwatch.stop());
-  }
-}

package/src/prerequisites/dns.ts

@@ -1,36 +0,0 @@
-import dns from "dns/promises";
-import * as tools from "@bgord/tools";
-import type { ClockPort } from "../clock.port";
-import * as prereqs from "../prerequisites.service";
-import { Timeout } from "../timeout.service";
-
-export class PrerequisiteDNS implements prereqs.Prerequisite {
-  readonly kind = "dns";
-  readonly label: prereqs.PrerequisiteLabelType;
-  readonly enabled?: boolean = true;
-
-  private readonly hostname: string;
-  readonly timeout: tools.Duration;
-
-  constructor(config: prereqs.PrerequisiteConfigType & { hostname: string; timeout?: tools.Duration }) {
-    this.label = config.label;
-    this.enabled = config.enabled === undefined ? true : config.enabled;
-
-    this.hostname = config.hostname;
-    this.timeout = config.timeout ?? tools.Duration.Seconds(1);
-  }
-
-  async verify(clock: ClockPort): Promise<prereqs.VerifyOutcome> {
-    const stopwatch = new tools.Stopwatch(clock.now());
-
-    if (!this.enabled) return prereqs.Verification.undetermined(stopwatch.stop());
-
-    try {
-      await Timeout.run(dns.lookup(this.hostname), this.timeout);
-
-      return prereqs.Verification.success(stopwatch.stop());
-    } catch (error) {
-      return prereqs.Verification.failure(stopwatch.stop(), error as Error);
-    }
-  }
-}

package/src/prerequisites/external-api.ts

@@ -1,41 +0,0 @@
-import * as tools from "@bgord/tools";
-import type { ClockPort } from "../clock.port";
-import * as prereqs from "../prerequisites.service";
-import { Timeout } from "../timeout.service";
-
-export class PrerequisiteExternalApi implements prereqs.Prerequisite {
-  readonly kind = "external-api";
-  readonly label: prereqs.PrerequisiteLabelType;
-  readonly enabled?: boolean = true;
-
-  private readonly request: (signal: AbortSignal) => Promise<Response>;
-  readonly timeout: tools.Duration;
-
-  constructor(
-    config: prereqs.PrerequisiteConfigType & {
-      request: (signal: AbortSignal) => Promise<Response>;
-      timeout?: tools.Duration;
-    },
-  ) {
-    this.label = config.label;
-    this.enabled = config.enabled === undefined ? true : config.enabled;
-
-    this.request = config.request;
-    this.timeout = config.timeout ?? tools.Duration.Seconds(2);
-  }
-
-  async verify(clock: ClockPort): Promise<prereqs.VerifyOutcome> {
-    const stopwatch = new tools.Stopwatch(clock.now());
-
-    if (!this.enabled) return prereqs.Verification.undetermined(stopwatch.stop());
-
-    try {
-      const response = await Timeout.cancellable((signal: AbortSignal) => this.request(signal), this.timeout);
-
-      if (response.ok) return prereqs.Verification.success(stopwatch.stop());
-      return prereqs.Verification.failure(stopwatch.stop(), { message: `HTTP ${response.status}` });
-    } catch (error) {
-      return prereqs.Verification.failure(stopwatch.stop(), error as Error);
-    }
-  }
-}

package/src/prerequisites/file.ts

@@ -1,69 +0,0 @@
-import { access, constants } from "node:fs/promises";
-import * as tools from "@bgord/tools";
-import type { ClockPort } from "../clock.port";
-import * as prereqs from "../prerequisites.service";
-
-export type PrerequisiteFilePermissionsType = { read?: boolean; write?: boolean; execute?: boolean };
-
-export class PrerequisiteFile implements prereqs.Prerequisite {
-  readonly kind = "file";
-  readonly label: prereqs.PrerequisiteLabelType;
-  readonly enabled?: boolean = true;
-
-  private readonly file: tools.FilePathAbsolute | tools.FilePathRelative;
-  private readonly permissions: PrerequisiteFilePermissionsType;
-
-  constructor(
-    config: prereqs.PrerequisiteConfigType & {
-      file: tools.FilePathAbsolute | tools.FilePathRelative;
-      permissions?: PrerequisiteFilePermissionsType;
-    },
-  ) {
-    this.label = config.label;
-    this.enabled = config.enabled === undefined ? true : config.enabled;
-
-    this.file = config.file;
-    this.permissions = config.permissions ?? {};
-  }
-
-  async verify(clock: ClockPort): Promise<prereqs.VerifyOutcome> {
-    const stopwatch = new tools.Stopwatch(clock.now());
-
-    if (!this.enabled) return prereqs.Verification.undetermined(stopwatch.stop());
-
-    try {
-      const path = this.file.get();
-
-      const exists = await Bun.file(path).exists();
-      if (!exists) return prereqs.Verification.failure(stopwatch.stop(), { message: "File does not exist" });
-
-      if (this.permissions.read) {
-        try {
-          await access(path, constants.R_OK);
-        } catch {
-          return prereqs.Verification.failure(stopwatch.stop(), { message: "File is not readable" });
-        }
-      }
-
-      if (this.permissions.write) {
-        try {
-          await access(path, constants.W_OK);
-        } catch {
-          return prereqs.Verification.failure(stopwatch.stop(), { message: "File is not writable" });
-        }
-      }
-
-      if (this.permissions.execute) {
-        try {
-          await access(path, constants.X_OK);
-        } catch {
-          return prereqs.Verification.failure(stopwatch.stop(), { message: "File is not executable" });
-        }
-      }
-
-      return prereqs.Verification.success(stopwatch.stop());
-    } catch (error) {
-      return prereqs.Verification.failure(stopwatch.stop(), error as Error);
-    }
-  }
-}

package/src/prerequisites/index.ts

@@ -1,24 +0,0 @@
-export * from "./binary";
-export * from "./bun";
-export * from "./clock-drift";
-export * from "./dependency-vulnerabilities";
-export * from "./directory";
-export * from "./dns";
-export * from "./external-api";
-export * from "./file";
-export * from "./jobs";
-export * from "./log-file";
-export * from "./mailer";
-export * from "./memory";
-export * from "./node";
-export * from "./os";
-export * from "./outside-connectivity";
-export * from "./port";
-export * from "./ram";
-export * from "./running-user";
-export * from "./self";
-export * from "./space";
-export * from "./sqlite";
-export * from "./ssl-certificate-expiry";
-export * from "./timezone-utc";
-export * from "./translations";

package/src/prerequisites/jobs.ts

@@ -1,27 +0,0 @@
-import * as tools from "@bgord/tools";
-import type { ClockPort } from "../clock.port";
-import { Jobs, type MultipleJobsType } from "../jobs.service";
-import * as prereqs from "../prerequisites.service";
-
-export class PrerequisiteJobs implements prereqs.Prerequisite {
-  readonly kind = "jobs";
-  readonly label: prereqs.PrerequisiteLabelType;
-  readonly enabled?: boolean = true;
-
-  private readonly Jobs: MultipleJobsType;
-
-  constructor(config: prereqs.PrerequisiteConfigType & { Jobs: MultipleJobsType }) {
-    this.label = config.label;
-    this.enabled = config.enabled === undefined ? true : config.enabled;
-
-    this.Jobs = config.Jobs;
-  }
-
-  async verify(clock: ClockPort): Promise<prereqs.VerifyOutcome> {
-    const stopwatch = new tools.Stopwatch(clock.now());
-
-    if (!this.enabled) return prereqs.Verification.undetermined(stopwatch.stop());
-    if (Jobs.areAllRunning(this.Jobs)) return prereqs.Verification.success(stopwatch.stop());
-    return prereqs.Verification.failure(stopwatch.stop());
-  }
-}

package/src/prerequisites/log-file.ts

@@ -1,42 +0,0 @@
-import * as tools from "@bgord/tools";
-import type { ClockPort } from "../clock.port";
-import type { LoggerPort } from "../logger.port";
-import * as prereqs from "../prerequisites.service";
-import { PrerequisiteFile } from "./file";
-
-type Dependencies = { Logger: LoggerPort };
-
-export class PrerequisiteLogFile implements prereqs.Prerequisite {
-  readonly kind = "log-file";
-  readonly label: prereqs.PrerequisiteLabelType;
-  readonly enabled?: boolean = true;
-
-  constructor(
-    config: prereqs.PrerequisiteConfigType,
-    private readonly deps: Dependencies,
-  ) {
-    this.label = config.label;
-    this.enabled = config.enabled === undefined ? true : config.enabled;
-  }
-
-  async verify(clock: ClockPort): Promise<prereqs.VerifyOutcome> {
-    const stopwatch = new tools.Stopwatch(clock.now());
-
-    if (!this.enabled) return prereqs.Verification.undetermined(stopwatch.stop());
-
-    try {
-      const path = this.deps.Logger.getFilePath();
-      if (!path) return prereqs.Verification.undetermined(stopwatch.stop());
-
-      const file = new PrerequisiteFile({
-        label: this.label,
-        file: path,
-        permissions: { read: true, write: true },
-      });
-
-      return file.verify(clock);
-    } catch (error) {
-      return prereqs.Verification.failure(stopwatch.stop(), error as Error);
-    }
-  }
-}

package/src/prerequisites/mailer.ts

@@ -1,38 +0,0 @@
-import * as tools from "@bgord/tools";
-import type { ClockPort } from "../clock.port";
-import type { MailerPort } from "../mailer.port";
-import * as prereqs from "../prerequisites.service";
-import { Timeout } from "../timeout.service";
-
-type Dependencies = { Mailer: MailerPort };
-
-export class PrerequisiteMailer implements prereqs.Prerequisite {
-  readonly kind = "mailer";
-  readonly label: prereqs.PrerequisiteLabelType;
-  readonly enabled?: boolean = true;
-
-  readonly timeout: tools.Duration;
-
-  constructor(
-    config: prereqs.PrerequisiteConfigType & { timeout?: tools.Duration },
-    private readonly deps: Dependencies,
-  ) {
-    this.label = config.label;
-    this.enabled = config.enabled === undefined ? true : config.enabled;
-
-    this.timeout = config.timeout ?? tools.Duration.Seconds(2);
-  }
-
-  async verify(clock: ClockPort): Promise<prereqs.VerifyOutcome> {
-    const stopwatch = new tools.Stopwatch(clock.now());
-
-    if (!this.enabled) return prereqs.Verification.undetermined(stopwatch.stop());
-
-    try {
-      await Timeout.run(this.deps.Mailer.verify(), this.timeout);
-      return prereqs.Verification.success(stopwatch.stop());
-    } catch (error) {
-      return prereqs.Verification.failure(stopwatch.stop(), error as Error);
-    }
-  }
-}

package/src/prerequisites/memory.ts

@@ -1,34 +0,0 @@
-import * as tools from "@bgord/tools";
-import type { ClockPort } from "../clock.port";
-import { MemoryConsumption } from "../memory-consumption.service";
-import * as prereqs from "../prerequisites.service";
-
-export class PrerequisiteMemory implements prereqs.Prerequisite {
-  readonly kind = "memory";
-  readonly label: prereqs.PrerequisiteLabelType;
-  readonly enabled?: boolean = true;
-
-  private readonly maximum: tools.Size;
-
-  constructor(config: prereqs.PrerequisiteConfigType & { maximum: tools.Size }) {
-    this.label = config.label;
-    this.enabled = config.enabled === undefined ? true : config.enabled;
-
-    this.maximum = config.maximum;
-  }
-
-  async verify(clock: ClockPort): Promise<prereqs.VerifyOutcome> {
-    const stopwatch = new tools.Stopwatch(clock.now());
-
-    if (!this.enabled) return prereqs.Verification.undetermined(stopwatch.stop());
-
-    const memoryConsumption = MemoryConsumption.get();
-
-    if (memoryConsumption.isGreaterThan(this.maximum)) {
-      return prereqs.Verification.failure(stopwatch.stop(), {
-        message: `Memory consumption: ${memoryConsumption.format(tools.Size.unit.MB)}`,
-      });
-    }
-    return prereqs.Verification.success(stopwatch.stop());
-  }
-}

package/src/prerequisites/node.ts

@@ -1,37 +0,0 @@
-import * as tools from "@bgord/tools";
-import type { ClockPort } from "../clock.port";
-import * as prereqs from "../prerequisites.service";
-
-export class PrerequisiteNode implements prereqs.Prerequisite {
-  readonly kind = "node";
-  readonly label: prereqs.PrerequisiteLabelType;
-  readonly enabled?: boolean = true;
-
-  private readonly version: tools.PackageVersion;
-  private readonly current: string;
-
-  constructor(config: prereqs.PrerequisiteConfigType & { version: tools.PackageVersion; current: string }) {
-    this.label = config.label;
-    this.enabled = config.enabled === undefined ? true : config.enabled;
-
-    this.version = config.version;
-    this.current = config.current;
-  }
-
-  async verify(clock: ClockPort): Promise<prereqs.VerifyOutcome> {
-    const stopwatch = new tools.Stopwatch(clock.now());
-
-    if (!this.enabled) return prereqs.Verification.undetermined(stopwatch.stop());
-
-    try {
-      const current = tools.PackageVersion.fromVersionString(this.current);
-
-      if (current.isGreaterThanOrEqual(this.version)) return prereqs.Verification.success(stopwatch.stop());
-      return prereqs.Verification.failure(stopwatch.stop(), { message: `Version: ${this.current}` });
-    } catch {
-      return prereqs.Verification.failure(stopwatch.stop(), {
-        message: `Invalid version passed: ${this.current}`,
-      });
-    }
-  }
-}

package/src/prerequisites/os.ts

@@ -1,33 +0,0 @@
-import os from "node:os";
-import * as tools from "@bgord/tools";
-import type { ClockPort } from "../clock.port";
-import * as prereqs from "../prerequisites.service";
-
-export class PrerequisiteOs implements prereqs.Prerequisite {
-  readonly kind = "os";
-  readonly label: prereqs.PrerequisiteLabelType;
-  readonly enabled?: boolean = true;
-
-  private readonly accepted: string[];
-
-  constructor(config: prereqs.PrerequisiteConfigType & { accepted: string[] }) {
-    this.label = config.label;
-    this.enabled = config.enabled === undefined ? true : config.enabled;
-    this.accepted = config.accepted;
-  }
-
-  async verify(clock: ClockPort): Promise<prereqs.VerifyOutcome> {
-    const stopwatch = new tools.Stopwatch(clock.now());
-
-    if (!this.enabled) return prereqs.Verification.undetermined(stopwatch.stop());
-
-    const type = os.type();
-
-    if (this.accepted.map((type) => type.toLowerCase()).includes(type.toLowerCase())) {
-      return prereqs.Verification.success(stopwatch.stop());
-    }
-    return prereqs.Verification.failure(stopwatch.stop(), {
-      message: `Unacceptable os: ${this.accepted.join(", ")}`,
-    });
-  }
-}