@bgord/bun 1.6.7 → 1.7.0

package/src/logger-winston-production.adapter.ts

@@ -3,12 +3,9 @@ import * as winston from "winston";
 import type { LogAppType, LoggerPort, LogLevelEnum } from "./logger.port";
 import { LoggerWinstonAdapter } from "./logger-winston.adapter";
 import { NodeEnvironmentEnum } from "./node-env.vo";
-import type { RedactorPort } from "./redactor.port";
+import type { RedactorStrategy } from "./redactor.strategy";
 
-type LoggerWinstonProductionAdapterConfigType = {
-  app: LogAppType;
-  redactor: RedactorPort;
-};
+type LoggerWinstonProductionAdapterConfigType = { app: LogAppType; redactor: RedactorStrategy };
 
 export class LoggerWinstonProductionAdapter {
   constructor(private readonly config: LoggerWinstonProductionAdapterConfigType) {}

package/src/logger-winston.adapter.ts

@@ -2,15 +2,15 @@ import type * as tools from "@bgord/tools";
 import * as winston from "winston";
 import { type LogAppType, type LoggerPort, LogLevelEnum } from "./logger.port";
 import type { NodeEnvironmentEnum } from "./node-env.vo";
-import type { RedactorPort } from "./redactor.port";
+import type { RedactorStrategy } from "./redactor.strategy";
 
 type WinstonLoggerOptions = {
   app: LogAppType;
   environment: NodeEnvironmentEnum;
   level: LogLevelEnum;
-  redactor: RedactorPort;
   formats?: winston.Logform.Format[];
   transports?: winston.transport[];
+  redactor: RedactorStrategy;
   filePath: tools.FilePathAbsolute | null;
 };
 

package/src/maintenance-mode.middleware.ts

@@ -0,0 +1,15 @@
+import * as tools from "@bgord/tools";
+import { createMiddleware } from "hono/factory";
+
+export type MaintenanceModeConfigType = { enabled: boolean; RetryAfter?: tools.Duration };
+
+export class MaintenanceMode {
+  static build = (config?: MaintenanceModeConfigType) =>
+    createMiddleware(async (c, next) => {
+      const enabled = config?.enabled ?? false;
+      const RetryAfter = config?.RetryAfter ?? tools.Duration.Hours(1);
+
+      if (!enabled) return next();
+      return c.json({ reason: "maintenance" }, 503, { "Retry-After": RetryAfter.seconds.toString() });
+    });
+}

package/src/modules/system/events/SECURITY_VIOLATION_DETECTED_EVENT.ts

@@ -0,0 +1,23 @@
+import { z } from "zod/v4";
+import { ClientIp } from "../../../client-ip.vo";
+import { ClientUserAgent } from "../../../client-user-agent.vo";
+import { EventEnvelopeSchema } from "../../../event-envelope";
+import { SecurityCountermeasureName } from "../../../security-countermeasure-name.vo";
+import { SecurityRuleName } from "../../../security-rule-name.vo";
+import { UUID } from "../../../uuid.vo";
+
+export const SECURITY_VIOLATION_DETECTED_EVENT = "SECURITY_VIOLATION_DETECTED_EVENT";
+
+export const SecurityViolationDetectedEvent = z.object({
+  ...EventEnvelopeSchema,
+  name: z.literal(SECURITY_VIOLATION_DETECTED_EVENT),
+  payload: z.object({
+    rule: SecurityRuleName,
+    client: z.object({ ip: ClientIp, ua: ClientUserAgent }),
+    userId: UUID.or(z.undefined()),
+    countermeasure: SecurityCountermeasureName,
+    action: z.string(),
+  }),
+});
+
+export type SecurityViolationDetectedEventType = z.infer<typeof SecurityViolationDetectedEvent>;

package/src/modules/system/events/index.ts

@@ -1,2 +1,3 @@
 export * from "./HOUR_HAS_PASSED_EVENT";
 export * from "./MINUTE_HAS_PASSED_EVENT";
+export * from "./SECURITY_VIOLATION_DETECTED_EVENT";

package/src/modules/system/services/passage-of-time-hourly.service.ts

@@ -2,7 +2,7 @@ import type { ClockPort } from "../../../clock.port";
 import { createEventEnvelope } from "../../../event-envelope";
 import type { EventStoreLike } from "../../../event-store-like.types";
 import type { IdProviderPort } from "../../../id-provider.port";
-import type { UnitOfWork } from "../../../job-handler.port";
+import type { UnitOfWork } from "../../../job-handler.strategy";
 import { Jobs } from "../../../jobs.service";
 import {
   HOUR_HAS_PASSED_EVENT,
@@ -24,12 +24,10 @@ export class PassageOfTimeHourly implements UnitOfWork {
   label = "PassageOfTime";
 
   async process() {
-    const timestamp = this.deps.Clock.nowMs();
-
     const event = HourHasPassedEvent.parse({
       ...createEventEnvelope("passage_of_time", this.deps),
       name: HOUR_HAS_PASSED_EVENT,
-      payload: { timestamp },
+      payload: { timestamp: this.deps.Clock.now().ms },
     } satisfies HourHasPassedEventType);
 
     await this.deps.EventStore.save([event]);

package/src/modules/system/services/passage-of-time-minute.service.ts

@@ -2,7 +2,7 @@ import type { ClockPort } from "../../../clock.port";
 import { createEventEnvelope } from "../../../event-envelope";
 import type { EventStoreLike } from "../../../event-store-like.types";
 import type { IdProviderPort } from "../../../id-provider.port";
-import type { UnitOfWork } from "../../../job-handler.port";
+import type { UnitOfWork } from "../../../job-handler.strategy";
 import { Jobs } from "../../../jobs.service";
 import {
   MINUTE_HAS_PASSED_EVENT,
@@ -24,12 +24,10 @@ export class PassageOfTimeMinute implements UnitOfWork {
   label = "PassageOfTime";
 
   async process() {
-    const timestamp = this.deps.Clock.nowMs();
-
     const event = MinuteHasPassedEvent.parse({
       ...createEventEnvelope("passage_of_time", this.deps),
       name: MINUTE_HAS_PASSED_EVENT,
-      payload: { timestamp },
+      payload: { timestamp: this.deps.Clock.now().ms },
     } satisfies MinuteHasPassedEventType);
 
     await this.deps.EventStore.save([event]);

package/src/prerequisite-runner-startup.service.ts

@@ -0,0 +1,44 @@
+import type { ClockPort } from "../src/clock.port";
+import type { LoggerPort } from "../src/logger.port";
+import type { Prerequisite } from "./prerequisite.vo";
+import { PrerequisiteVerificationOutcome } from "./prerequisite-verifier.port";
+
+export const PrerequisitesError = { Failure: "prerequisites.failure" } as const;
+
+type Dependencies = { Logger: LoggerPort; Clock: ClockPort };
+
+/** @public */
+export class PrerequisiteRunnerStartup {
+  private readonly base = { component: "infra", operation: "startup" };
+
+  constructor(private readonly deps: Dependencies) {}
+
+  async check(prerequisites: Prerequisite[]) {
+    const result = await Promise.all(
+      prerequisites
+        .filter((prerequisite) => prerequisite.enabled)
+        .map(async (prerequisite) => ({
+          prerequisite,
+          outcome: await prerequisite.build().verify(),
+        })),
+    );
+
+    const failures = result.filter(
+      (result) => result.outcome.outcome === PrerequisiteVerificationOutcome.failure,
+    );
+
+    if (failures.length === 0) return this.deps.Logger.info({ message: "Prerequisites ok", ...this.base });
+
+    for (const failure of failures) {
+      this.deps.Logger.error({
+        message: "Prerequisite failed",
+        metadata: { label: failure.prerequisite.label, kind: failure.prerequisite.kind },
+        // @ts-expect-error
+        error: failure.outcome.error ?? { message: "unknown error" },
+        ...this.base,
+      });
+    }
+
+    throw new Error(PrerequisitesError.Failure);
+  }
+}

package/src/prerequisite-verifier-binary.adapter.ts

@@ -0,0 +1,21 @@
+import type { BinaryType } from "./binary.vo";
+import { PrerequisiteVerification, type PrerequisiteVerifierPort } from "./prerequisite-verifier.port";
+
+export class PrerequisiteVerifierBinaryAdapter implements PrerequisiteVerifierPort {
+  constructor(private readonly config: { binary: BinaryType }) {}
+
+  async verify() {
+    try {
+      const result = Bun.which(this.config.binary);
+
+      if (result) return PrerequisiteVerification.success;
+      return PrerequisiteVerification.failure();
+    } catch (error) {
+      return PrerequisiteVerification.failure(error as Error);
+    }
+  }
+
+  get kind() {
+    return "binary";
+  }
+}

package/src/prerequisite-verifier-bun.adapter.ts

@@ -0,0 +1,21 @@
+import * as tools from "@bgord/tools";
+import { PrerequisiteVerification, type PrerequisiteVerifierPort } from "./prerequisite-verifier.port";
+
+export class PrerequisiteVerifierBunAdapter implements PrerequisiteVerifierPort {
+  constructor(private readonly config: { version: tools.PackageVersion; current: string }) {}
+
+  async verify() {
+    try {
+      const current = tools.PackageVersion.fromString(this.config.current);
+
+      if (current.isGreaterThanOrEqual(this.config.version)) return PrerequisiteVerification.success;
+      return PrerequisiteVerification.failure({ message: `Version: ${this.config.version.toString()}` });
+    } catch {
+      return PrerequisiteVerification.failure({ message: `Invalid version passed: ${this.config.current}` });
+    }
+  }
+
+  get kind() {
+    return "bun";
+  }
+}

package/src/prerequisite-verifier-clock-drift.adapter.ts

@@ -0,0 +1,32 @@
+import type * as tools from "@bgord/tools";
+import type { ClockPort } from "./clock.port";
+import { PrerequisiteVerification, type PrerequisiteVerifierPort } from "./prerequisite-verifier.port";
+import type { TimekeeperPort } from "./timekeeper.port";
+
+type Dependencies = { Clock: ClockPort; Timekeeper: TimekeeperPort };
+
+export class PrerequisiteVerifierClockDriftAdapter implements PrerequisiteVerifierPort {
+  constructor(
+    private readonly config: { skew: tools.Duration },
+    private readonly deps: Dependencies,
+  ) {}
+
+  async verify() {
+    try {
+      const timestamp = await this.deps.Timekeeper.get();
+
+      if (!timestamp) return PrerequisiteVerification.undetermined;
+
+      const duration = this.deps.Clock.now().difference(timestamp).toAbsolute();
+
+      if (duration.isShorterThan(this.config.skew)) return PrerequisiteVerification.success;
+      return PrerequisiteVerification.failure({ message: `Difference: ${duration.seconds}s` });
+    } catch (error) {
+      return PrerequisiteVerification.undetermined;
+    }
+  }
+
+  get kind() {
+    return "clock-drift";
+  }
+}

package/src/prerequisite-verifier-dependency-vulnerabilities.adapter.ts

@@ -0,0 +1,38 @@
+import bun from "bun";
+import { PrerequisiteVerification, type PrerequisiteVerifierPort } from "./prerequisite-verifier.port";
+
+type BunAuditOutput = { [packageName: string]: { severity: "low" | "moderate" | "high" | "critical" }[] };
+
+export class PrerequisiteVerifierDependencyVulnerabilitiesAdapter implements PrerequisiteVerifierPort {
+  async verify() {
+    try {
+      const command = await bun.$`bun audit --json`.quiet();
+
+      if (command.exitCode !== 0) return PrerequisiteVerification.failure({ message: "Audit failure" });
+
+      const audit = JSON.parse(command.stdout.toString()) as BunAuditOutput;
+
+      const criticalVulnerabilities = Object.values(audit).filter((name) =>
+        name.some((vulnerability) => vulnerability.severity === "critical"),
+      ).length;
+
+      const highVulnerabilities = Object.values(audit).filter((name) =>
+        name.some((vulnerability) => vulnerability.severity === "high"),
+      ).length;
+
+      if (criticalVulnerabilities > 0 || highVulnerabilities > 0) {
+        const message = `Critical: ${criticalVulnerabilities} and high: ${highVulnerabilities}`;
+
+        return PrerequisiteVerification.failure({ message });
+      }
+
+      return PrerequisiteVerification.success;
+    } catch (error) {
+      return PrerequisiteVerification.failure(error as Error);
+    }
+  }
+
+  get kind() {
+    return "dependency-vulnerabilities";
+  }
+}

package/src/prerequisite-verifier-directory.adapter.ts

@@ -0,0 +1,56 @@
+import { access, constants, stat } from "node:fs/promises";
+import type * as tools from "@bgord/tools";
+import { PrerequisiteVerification, type PrerequisiteVerifierPort } from "./prerequisite-verifier.port";
+
+export type PrerequisiteDirectoryPermissionsType = { read?: boolean; write?: boolean; execute?: boolean };
+
+export class PrerequisiteVerifierDirectoryAdapter implements PrerequisiteVerifierPort {
+  constructor(
+    private readonly config: {
+      directory: tools.DirectoryPathAbsoluteType | tools.DirectoryPathRelativeType;
+      permissions?: PrerequisiteDirectoryPermissionsType;
+    },
+  ) {}
+
+  async verify() {
+    try {
+      const stats = await stat(this.config.directory);
+
+      if (!stats.isDirectory()) return PrerequisiteVerification.failure({ message: "Not a directory" });
+    } catch {
+      return PrerequisiteVerification.failure({ message: "Directory does not exist" });
+    }
+
+    const permissions = this.config.permissions ?? {};
+
+    if (permissions.read) {
+      try {
+        await access(this.config.directory, constants.R_OK);
+      } catch {
+        return PrerequisiteVerification.failure({ message: "Directory is not readable" });
+      }
+    }
+
+    if (permissions.write) {
+      try {
+        await access(this.config.directory, constants.W_OK);
+      } catch {
+        return PrerequisiteVerification.failure({ message: "Directory is not writable" });
+      }
+    }
+
+    if (permissions.execute) {
+      try {
+        await access(this.config.directory, constants.X_OK);
+      } catch {
+        return PrerequisiteVerification.failure({ message: "Directory is not executable" });
+      }
+    }
+
+    return PrerequisiteVerification.success;
+  }
+
+  get kind() {
+    return "directory";
+  }
+}

package/src/prerequisite-verifier-dns.adapter.ts

@@ -0,0 +1,20 @@
+import dns from "dns/promises";
+import { PrerequisiteVerification, type PrerequisiteVerifierPort } from "./prerequisite-verifier.port";
+
+export class PrerequisiteVerifierDnsAdapter implements PrerequisiteVerifierPort {
+  constructor(private readonly config: { hostname: string }) {}
+
+  async verify() {
+    try {
+      await dns.lookup(this.config.hostname);
+
+      return PrerequisiteVerification.success;
+    } catch (error) {
+      return PrerequisiteVerification.failure(error as Error);
+    }
+  }
+
+  get kind() {
+    return "dns";
+  }
+}

package/src/prerequisite-verifier-external-api.adapter.ts

@@ -0,0 +1,20 @@
+import { PrerequisiteVerification, type PrerequisiteVerifierPort } from "./prerequisite-verifier.port";
+
+export class PrerequisiteVerifierExternalApiAdapter implements PrerequisiteVerifierPort {
+  constructor(private readonly config: { request: () => Promise<Response> }) {}
+
+  async verify() {
+    try {
+      const response = await this.config.request();
+
+      if (response.ok) return PrerequisiteVerification.success;
+      return PrerequisiteVerification.failure({ message: `HTTP ${response.status}` });
+    } catch (error) {
+      return PrerequisiteVerification.failure(error as Error);
+    }
+  }
+
+  get kind() {
+    return "external-api";
+  }
+}

package/src/prerequisite-verifier-file.adapter.ts

@@ -0,0 +1,57 @@
+import { access, constants } from "node:fs/promises";
+import type * as tools from "@bgord/tools";
+import { PrerequisiteVerification, type PrerequisiteVerifierPort } from "./prerequisite-verifier.port";
+
+export type PrerequisiteFilePermissionsType = { read?: boolean; write?: boolean; execute?: boolean };
+
+export class PrerequisiteVerifierFileAdapter implements PrerequisiteVerifierPort {
+  constructor(
+    private readonly config: {
+      file: tools.FilePathAbsolute | tools.FilePathRelative;
+      permissions?: PrerequisiteFilePermissionsType;
+    },
+  ) {}
+
+  async verify() {
+    try {
+      const path = this.config.file.get();
+
+      const exists = await Bun.file(path).exists();
+      if (!exists) return PrerequisiteVerification.failure({ message: "File does not exist" });
+
+      const permissions = this.config.permissions ?? {};
+
+      if (permissions.read) {
+        try {
+          await access(path, constants.R_OK);
+        } catch {
+          return PrerequisiteVerification.failure({ message: "File is not readable" });
+        }
+      }
+
+      if (permissions.write) {
+        try {
+          await access(path, constants.W_OK);
+        } catch {
+          return PrerequisiteVerification.failure({ message: "File is not writable" });
+        }
+      }
+
+      if (permissions.execute) {
+        try {
+          await access(path, constants.X_OK);
+        } catch {
+          return PrerequisiteVerification.failure({ message: "File is not executable" });
+        }
+      }
+
+      return PrerequisiteVerification.success;
+    } catch (error) {
+      return PrerequisiteVerification.failure(error as Error);
+    }
+  }
+
+  get kind() {
+    return "file";
+  }
+}

package/src/prerequisite-verifier-jobs.adapter.ts

@@ -0,0 +1,15 @@
+import { Jobs, type MultipleJobsType } from "./jobs.service";
+import { PrerequisiteVerification, type PrerequisiteVerifierPort } from "./prerequisite-verifier.port";
+
+export class PrerequisiteVerifierJobsAdapter implements PrerequisiteVerifierPort {
+  constructor(private readonly config: { Jobs: MultipleJobsType }) {}
+
+  async verify() {
+    if (Jobs.areAllRunning(this.config.Jobs)) return PrerequisiteVerification.success;
+    return PrerequisiteVerification.failure();
+  }
+
+  get kind() {
+    return "jobs";
+  }
+}

package/src/prerequisite-verifier-log-file.adapter.ts

@@ -0,0 +1,29 @@
+import type { LoggerPort } from "./logger.port";
+import { PrerequisiteVerification, type PrerequisiteVerifierPort } from "./prerequisite-verifier.port";
+import { PrerequisiteVerifierFileAdapter } from "./prerequisite-verifier-file.adapter";
+
+type Dependencies = { Logger: LoggerPort };
+
+export class PrerequisiteVerifierLogFileAdapter implements PrerequisiteVerifierPort {
+  constructor(private readonly deps: Dependencies) {}
+
+  async verify() {
+    try {
+      const path = this.deps.Logger.getFilePath();
+      if (!path) return PrerequisiteVerification.undetermined;
+
+      const file = new PrerequisiteVerifierFileAdapter({
+        file: path,
+        permissions: { read: true, write: true },
+      });
+
+      return file.verify();
+    } catch (error) {
+      return PrerequisiteVerification.failure(error as Error);
+    }
+  }
+
+  get kind() {
+    return "log-file";
+  }
+}

package/src/prerequisite-verifier-mailer.adapter.ts

@@ -0,0 +1,22 @@
+import type { MailerPort } from "./mailer.port";
+import { PrerequisiteVerification, type PrerequisiteVerifierPort } from "./prerequisite-verifier.port";
+
+type Dependencies = { Mailer: MailerPort };
+
+export class PrerequisiteVerifierMailerAdapter implements PrerequisiteVerifierPort {
+  constructor(private readonly deps: Dependencies) {}
+
+  async verify() {
+    try {
+      await this.deps.Mailer.verify();
+
+      return PrerequisiteVerification.success;
+    } catch (error) {
+      return PrerequisiteVerification.failure(error as Error);
+    }
+  }
+
+  get kind() {
+    return "mailer";
+  }
+}

package/src/prerequisite-verifier-memory.adapter.ts

@@ -0,0 +1,22 @@
+import * as tools from "@bgord/tools";
+import { MemoryConsumption } from "./memory-consumption.service";
+import { PrerequisiteVerification, type PrerequisiteVerifierPort } from "./prerequisite-verifier.port";
+
+export class PrerequisiteVerifierMemoryAdapter implements PrerequisiteVerifierPort {
+  constructor(private readonly config: { maximum: tools.Size }) {}
+
+  async verify() {
+    const memoryConsumption = MemoryConsumption.get();
+
+    if (memoryConsumption.isGreaterThan(this.config.maximum)) {
+      const formatted = memoryConsumption.format(tools.Size.unit.MB);
+
+      return PrerequisiteVerification.failure({ message: `Memory consumption: ${formatted}` });
+    }
+    return PrerequisiteVerification.success;
+  }
+
+  get kind() {
+    return "memory";
+  }
+}

package/src/prerequisite-verifier-node.adapter.ts

@@ -0,0 +1,21 @@
+import * as tools from "@bgord/tools";
+import { PrerequisiteVerification, type PrerequisiteVerifierPort } from "./prerequisite-verifier.port";
+
+export class PrerequisiteVerifierNodeAdapter implements PrerequisiteVerifierPort {
+  constructor(private readonly config: { version: tools.PackageVersion; current: string }) {}
+
+  async verify() {
+    try {
+      const current = tools.PackageVersion.fromVersionString(this.config.current);
+
+      if (current.isGreaterThanOrEqual(this.config.version)) return PrerequisiteVerification.success;
+      return PrerequisiteVerification.failure({ message: `Version: ${this.config.current}` });
+    } catch {
+      return PrerequisiteVerification.failure({ message: `Invalid version passed: ${this.config.current}` });
+    }
+  }
+
+  get kind() {
+    return "node";
+  }
+}

package/src/prerequisite-verifier-os.adapter.ts

@@ -0,0 +1,22 @@
+import os from "node:os";
+import { PrerequisiteVerification, type PrerequisiteVerifierPort } from "./prerequisite-verifier.port";
+
+export class PrerequisiteVerifierOsAdapter implements PrerequisiteVerifierPort {
+  constructor(private readonly config: { accepted: string[] }) {}
+
+  async verify() {
+    const type = os.type().toLowerCase();
+
+    if (this.config.accepted.map((given) => given.toLowerCase()).includes(type)) {
+      return PrerequisiteVerification.success;
+    }
+
+    return PrerequisiteVerification.failure({
+      message: `Unacceptable os: ${this.config.accepted.join(", ")}`,
+    });
+  }
+
+  get kind() {
+    return "os";
+  }
+}

package/src/prerequisite-verifier-outside-connectivity.adapter.ts

@@ -0,0 +1,23 @@
+import * as tools from "@bgord/tools";
+import { PrerequisiteVerification, type PrerequisiteVerifierPort } from "./prerequisite-verifier.port";
+
+export class PrerequisiteVerifierOutsideConnectivityAdapter implements PrerequisiteVerifierPort {
+  private static readonly URL = tools.UrlWithoutSlash.parse("https://google.com");
+
+  constructor() {}
+
+  async verify() {
+    try {
+      const response = await fetch(PrerequisiteVerifierOutsideConnectivityAdapter.URL, { method: "HEAD" });
+
+      if (response.ok) return PrerequisiteVerification.success;
+      return PrerequisiteVerification.failure({ message: `HTTP ${response.status}` });
+    } catch (error) {
+      return PrerequisiteVerification.failure(error as Error);
+    }
+  }
+
+  get kind() {
+    return "outside-connectivity";
+  }
+}

package/src/prerequisite-verifier-port.adapter.ts

@@ -0,0 +1,23 @@
+import net from "node:net";
+import type { PortType } from "./port.vo";
+import {
+  PrerequisiteVerification,
+  type PrerequisiteVerificationResult,
+  type PrerequisiteVerifierPort,
+} from "./prerequisite-verifier.port";
+
+export class PrerequisiteVerifierPortAdapter implements PrerequisiteVerifierPort {
+  constructor(private readonly config: { port: PortType }) {}
+
+  async verify(): Promise<PrerequisiteVerificationResult> {
+    return new Promise((resolve) => {
+      const server = net.createServer();
+      server.listen(this.config.port, () => server.close(() => resolve(PrerequisiteVerification.success)));
+      server.on("error", () => resolve(PrerequisiteVerification.failure()));
+    });
+  }
+
+  get kind() {
+    return "port";
+  }
+}

package/src/prerequisite-verifier-ram.adapter.ts

@@ -0,0 +1,20 @@
+import os from "node:os";
+import * as tools from "@bgord/tools";
+import { PrerequisiteVerification, type PrerequisiteVerifierPort } from "./prerequisite-verifier.port";
+
+export class PrerequisiteVerifierRamAdapter implements PrerequisiteVerifierPort {
+  constructor(private readonly config: { minimum: tools.Size }) {}
+
+  async verify() {
+    const freeRAM = tools.Size.fromBytes(os.freemem());
+
+    if (freeRAM.isGreaterThan(this.config.minimum)) return PrerequisiteVerification.success;
+
+    const formatted = freeRAM.format(tools.Size.unit.MB);
+    return PrerequisiteVerification.failure({ message: `Free RAM: ${formatted}` });
+  }
+
+  get kind() {
+    return "ram";
+  }
+}