import {  type BackgroundBooleanState,  type HostPowerSnapshot,  type HostPowerThermalState,} from "@t3tools/contracts";import {  getBackgroundActivityPresetSettings,  resolveServerBackgroundActivitySettings,} from "@t3tools/shared/backgroundActivitySettings";import { HostProcessPlatform } from "@t3tools/shared/hostProcess";import * as Context from "effect/Context";import * as DateTime from "effect/DateTime";import * as Duration from "effect/Duration";import * as Effect from "effect/Effect";import * as Layer from "effect/Layer";import * as PubSub from "effect/PubSub";import * as Ref from "effect/Ref";import * as Stream from "effect/Stream"; import * as ProcessRunner from "../processRunner.ts";import { ServerSettingsService } from "../serverSettings.ts"; export interface HostPowerMonitorShape {  readonly snapshot: Effect.Effect<HostPowerSnapshot>;  readonly report: (snapshot: HostPowerSnapshot) => Effect.Effect<void>;  readonly setDemandActive: (active: boolean) => Effect.Effect<void>;  readonly streamChanges: Stream.Stream<HostPowerSnapshot>;} export class HostPowerMonitor extends Context.Service<HostPowerMonitor, HostPowerMonitorShape>()(  "t3/background/HostPowerMonitor",) {} const COMMAND_TIMEOUT = Duration.seconds(3); export const makeUnknownSnapshot = (  source: HostPowerSnapshot["source"],  updatedAt: HostPowerSnapshot["updatedAt"],): HostPowerSnapshot => ({  source,  idle: "unknown",  idleSeconds: null,  locked: "unknown",  suspended: false,  onBattery: "unknown",  lowPowerMode: "unknown",  thermalState: "unknown",  stale: true,  updatedAt,}); function boolState(value: boolean | null): BackgroundBooleanState {  if (value === null) return "unknown";  return value ? "true" : "false";} function parseIdleSeconds(ioregOutput: string): number | null {  const match = /"HIDIdleTime"\s*=\s*(\d+)/u.exec(ioregOutput);  if (!match) return null;  const nanoseconds = Number(match[1]);  return Number.isFinite(nanoseconds) ? Math.floor(nanoseconds / 1_000_000_000) : null;} function parseOnBattery(pmsetBatteryOutput: string): boolean | null {  if (/Now drawing from 'Battery Power'/iu.test(pmsetBatteryOutput)) return true;  if (/Now drawing from 'AC Power'/iu.test(pmsetBatteryOutput)) return false;  return null;} function parseLowPowerMode(pmsetOutput: string): boolean | null {  const match = /^\s*lowpowermode\s+([01])\s*$/imu.exec(pmsetOutput);  if (!match) return null;  return match[1] === "1";} function parseThermalState(_output: string): HostPowerThermalState {  // The stable shell adapter intentionally does not parse `pmset thermlog`;  // native adapters can provide this without depending on human-formatted text.  return "unknown";} function runOptional(  runner: ProcessRunner.ProcessRunnerShape,  command: string,  args: ReadonlyArray<string>,) {  return runner    .run({      command,      args,      timeout: COMMAND_TIMEOUT,      timeoutBehavior: "timedOutResult",      outputMode: "truncate",      maxOutputBytes: 32_000,    })    .pipe(Effect.option);} const readMacShellSnapshot = Effect.fn("background.hostPower.readMacShellSnapshot")(function* () {  const runner = yield* ProcessRunner.ProcessRunner;  const updatedAt = yield* DateTime.now;  const [idleOutput, batteryOutput, pmsetOutput] = yield* Effect.all(    [      runOptional(runner, "ioreg", ["-c", "IOHIDSystem"]),      runOptional(runner, "pmset", ["-g", "batt"]),      runOptional(runner, "pmset", ["-g"]),    ],    { concurrency: "unbounded" },  );   const idleSeconds = idleOutput._tag === "Some" ? parseIdleSeconds(idleOutput.value.stdout) : null;  const onBattery =    batteryOutput._tag === "Some" ? parseOnBattery(batteryOutput.value.stdout) : null;  const lowPowerMode =    pmsetOutput._tag === "Some" ? parseLowPowerMode(pmsetOutput.value.stdout) : null;   return {    source: "node-macos-shell",    idle: boolState(idleSeconds === null ? null : idleSeconds >= 60),    idleSeconds,    locked: "unknown",    suspended: false,    onBattery: boolState(onBattery),    lowPowerMode: boolState(lowPowerMode),    thermalState: parseThermalState(""),    stale: false,    updatedAt,  } satisfies HostPowerSnapshot;}); export const make = Effect.fn("background.hostPower.make")(function* (  initialSource: HostPowerSnapshot["source"] = "unknown",) {  const initial = makeUnknownSnapshot(initialSource, yield* DateTime.now);  const latestRef = yield* Ref.make(initial);  const demandActiveRef = yield* Ref.make(false);  const changes = yield* PubSub.sliding<HostPowerSnapshot>(1);   const report: HostPowerMonitorShape["report"] = (snapshot) =>    Ref.set(latestRef, snapshot).pipe(      Effect.andThen(PubSub.publish(changes, snapshot)),      Effect.asVoid,    );   return HostPowerMonitor.of({    snapshot: Ref.get(latestRef),    report,    setDemandActive: (active) => Ref.set(demandActiveRef, active),    streamChanges: Stream.fromPubSub(changes),  });}); const unknownLayer = Layer.effect(HostPowerMonitor, make("unknown"));const linuxLayer = Layer.effect(HostPowerMonitor, make("node-linux"));const windowsLayer = Layer.effect(HostPowerMonitor, make("node-windows")); const macShellLayer = Layer.effect(  HostPowerMonitor,  Effect.gen(function* () {    const serverSettings = yield* ServerSettingsService;    const monitor = yield* make("node-macos-shell");    const demandActiveRef = yield* Ref.make(true);    const setDemandActive: HostPowerMonitorShape["setDemandActive"] = (active) =>      Ref.set(demandActiveRef, active);    const getPollInterval = Effect.gen(function* () {      const demandActive = yield* Ref.get(demandActiveRef);      const settings = yield* serverSettings.getSettings.pipe(        Effect.map(resolveServerBackgroundActivitySettings),        Effect.catch(() => Effect.succeed(getBackgroundActivityPresetSettings("balanced"))),      );      return demandActive        ? settings.hostPowerMonitorActiveInterval        : settings.hostPowerMonitorIdleInterval;    });    const adaptiveMonitor = HostPowerMonitor.of({      snapshot: monitor.snapshot,      report: monitor.report,      setDemandActive,      streamChanges: monitor.streamChanges,    });    yield* readMacShellSnapshot().pipe(      Effect.flatMap(adaptiveMonitor.report),      Effect.ignoreCause({ log: true }),    );    yield* Effect.forever(      getPollInterval.pipe(        Effect.flatMap((interval) => Effect.sleep(Duration.max(interval, Duration.seconds(5)))),        Effect.andThen(readMacShellSnapshot()),        Effect.flatMap(adaptiveMonitor.report),        Effect.ignoreCause({ log: true }),      ),    ).pipe(Effect.forkScoped);    return adaptiveMonitor;  }),).pipe(Layer.provide(ProcessRunner.layer)); export const layer = Layer.unwrap(  Effect.gen(function* () {    const platform = yield* HostProcessPlatform;    switch (platform) {      case "darwin":        return macShellLayer;      case "linux":        return linuxLayer;      case "win32":        return windowsLayer;      default:        return unknownLayer;    }  }),);