import * as HostProcess from "@t3tools/shared/HostProcess"; import * as Context from "effect/Context"; import * as Effect from "effect/Effect"; import * as FileSystem from "effect/FileSystem"; import * as Layer from "effect/Layer"; import * as Option from "effect/Option"; import * as Path from "effect/Path"; import * as Schema from "effect/Schema"; import * as ServerConfig from "../config.ts"; export class ResourceMonitorBinaryUnsupported extends Schema.TaggedError()( "ResourceMonitorBinaryUnsupported", { platform: Schema.String, architecture: Schema.String, }, ) { override get message(): string { return `Resource monitoring is unsupported on ${this.platform}/${this.architecture}.`; } } export class ResourceMonitorBinaryNotFound extends Schema.TaggedError()( "ResourceMonitorBinaryNotFound", { platform: Schema.String, architecture: Schema.String, candidates: Schema.Array(Schema.String), }, ) { override get message(): string { return `Resource monitor binary was not found for ${this.platform}/${this.architecture}.`; } } export class ResourceMonitorBinaryNotExecutable extends Schema.TaggedError()( "ResourceMonitorBinaryNotExecutable", { path: Schema.String, mode: Schema.Number, }, ) { override get message(): string { return `Resource monitor binary at '${this.path}' is not executable.`; } } export type ResourceMonitorBinaryError = | ResourceMonitorBinaryUnsupported | ResourceMonitorBinaryNotFound | ResourceMonitorBinaryNotExecutable; export class ResourceMonitorBinary extends Context.Service< ResourceMonitorBinary, { readonly resolve: Effect.Effect; } >()("t3/resourceTelemetry/ResourceMonitorBinary") {} function binaryName(platform: NodeJS.Platform): string { return platform === "win32" ? "t3-resource-monitor.exe" : "t3-resource-monitor"; } function resourceMonitorPlatformKey( platform: NodeJS.Platform, architecture: NodeJS.Architecture, ): string | undefined { if ( (platform !== "darwin" && platform !== "linux" && platform !== "win32") || (architecture !== "arm64" && architecture !== "x64") ) { return undefined; } return `${platform}-${architecture}`; } function resourceMonitorRustTarget( platform: NodeJS.Platform, architecture: NodeJS.Architecture, linuxLibc?: typeof HostProcess.LinuxLibc.Service, ): string | undefined { if (platform === "darwin") { return architecture === "arm64" ? "aarch64-apple-darwin" : architecture === "x64" ? "x86_64-apple-darwin" : undefined; } if (platform === "linux") { if (linuxLibc !== "gnu") { return undefined; } return architecture === "arm64" ? "aarch64-unknown-linux-gnu" : architecture === "x64" ? "x86_64-unknown-linux-gnu" : undefined; } if (platform === "win32") { return architecture === "arm64" ? "aarch64-pc-windows-msvc" : architecture === "x64" ? "x86_64-pc-windows-msvc" : undefined; } return undefined; } export const make = Effect.fn("resourceTelemetry.resourceMonitorBinary.make")(function* () { const config = yield* ServerConfig.ServerConfig; const fileSystem = yield* FileSystem.FileSystem; const path = yield* Path.Path; const platform = yield* HostProcess.Platform; const architecture = yield* HostProcess.Architecture; const environment = yield* HostProcess.Environment; const linuxLibc = platform === "linux" ? yield* HostProcess.LinuxLibc : undefined; const executableName = binaryName(platform); const platformKey = resourceMonitorPlatformKey(platform, architecture); const rustTarget = resourceMonitorRustTarget(platform, architecture, linuxLibc); const overrideCandidates = [ environment.T3CODE_RESOURCE_MONITOR_PATH, config.resourceMonitorPath, ].filter((candidate): candidate is string => Boolean(candidate)); const cargoOutputDirectories = rustTarget === undefined ? [] : [ path.join("target", rustTarget, "release"), path.join("target", "release"), path.join("target", "debug"), ]; const sourceCandidates = [ path.resolve(import.meta.dirname, "../../../../native/resource-monitor"), path.resolve(import.meta.dirname, "../../../native/resource-monitor"), ].flatMap((crateDirectory) => cargoOutputDirectories.map((directory) => path.join(crateDirectory, directory, executableName)), ); const bundledCandidates = platformKey === undefined || rustTarget === undefined ? [] : [ path.resolve(import.meta.dirname, "resource-monitor", platformKey, executableName), path.resolve(import.meta.dirname, "resource-monitor", executableName), path.resolve(import.meta.dirname, "../resource-monitor", executableName), ...sourceCandidates, ]; if (overrideCandidates.length === 0 && bundledCandidates.length === 0) { return ResourceMonitorBinary.of({ resolve: Effect.fail( new ResourceMonitorBinaryUnsupported({ platform, architecture, }), ), }); } const candidates = [...overrideCandidates, ...bundledCandidates]; const resolve: ResourceMonitorBinary["Service"]["resolve"] = Effect.gen(function* () { for (const candidate of candidates) { const exists = yield* fileSystem.exists(candidate).pipe(Effect.orElseSucceed(() => false)); if (!exists) continue; const stat = yield* fileSystem.stat(candidate).pipe(Effect.option); if (Option.isSome(stat)) { // Windows skips exec-bit checks, so directories would otherwise pass until spawn. const unusable = stat.value.type === "Directory" || (platform !== "win32" && (stat.value.mode & 0o111) === 0); if (unusable) { return yield* new ResourceMonitorBinaryNotExecutable({ path: candidate, mode: stat.value.mode, }); } } return candidate; } return yield* new ResourceMonitorBinaryNotFound({ platform, architecture, candidates, }); }); return ResourceMonitorBinary.of({ resolve }); }); export const layer = Layer.effect(ResourceMonitorBinary, make());