miravo 0.1.4 → 0.2.0

package/src/output.ts

@@ -3,7 +3,8 @@
  * Uses consola/utils for ANSI-aware width calculation.
  */
 
-import { stripAnsi } from "consola/utils";
+import type { AdapterHealthSnapshot, AdapterMetrics } from "@miravo/shared";
+import { colors, stripAnsi } from "consola/utils";
 
 /** A single row in a table, where each cell is a string value keyed by column key. */
 interface TableRow {
@@ -115,3 +116,42 @@ export function formatDuration(ms: number): string {
 
   return parts.join(" ");
 }
+
+/**
+ * Format the health suffix for an adapter line in pretty/plain CLI output.
+ * Returns a string like: " · State: healthy" or " · Pending: 18,420 · State: saturated"
+ */
+export function formatHealthSuffix(metrics: AdapterMetrics, sep: string): string {
+  const health = metrics.health;
+  if (!health) return "";
+
+  let suffix = "";
+
+  if (health.pendingWorkCount > 0) {
+    suffix += `${sep}Pending: ${colors.yellow(formatCount(health.pendingWorkCount))}`;
+  }
+
+  suffix += `${sep}State: ${healthStateColor(health.state)}`;
+
+  return suffix;
+}
+
+function healthStateColor(state: AdapterHealthSnapshot["state"]): string {
+  switch (state) {
+    case "healthy":
+      return colors.green(state);
+    case "busy":
+      return colors.yellow(state);
+    case "saturated":
+      return colors.red(state);
+  }
+}
+
+/**
+ * Compute average throughput over the entire run.
+ * Returns null when there's no meaningful data (zero uptime or zero messages).
+ */
+export function computeAverageThroughput(totalMessages: number, uptimeMs: number): number | null {
+  if (uptimeMs <= 0 || totalMessages === 0) return null;
+  return Math.round(totalMessages / (uptimeMs / 1_000));
+}

package/src/lib/health-server.test.ts

@@ -1,161 +0,0 @@
-import { afterEach, describe, expect, test } from "bun:test";
-import type { EngineCoreMetrics, EngineStateSnapshot } from "@miravo/core";
-import { startHealthServer } from "./health-server.ts";
-
-function createMockHealthEngine(initialState: EngineCoreMetrics["state"], tickIntervalMs: number) {
-  const runtime = {
-    state: initialState as EngineCoreMetrics["state"],
-    tickCount: 0,
-    lastTickProgressAt: Date.now(),
-  };
-
-  const snapshot: EngineStateSnapshot = {
-    simulationName: "test-sim",
-    models: [],
-    instances: [],
-    config: {
-      seed: 1,
-      tickIntervalMs,
-      timeMultiplier: 1,
-      adapters: [],
-    },
-  };
-
-  return {
-    engine: {
-      getMetrics: () => ({
-        core: {
-          state: runtime.state,
-          tickCount: runtime.tickCount,
-          simulationTimeSeconds: 0,
-          instanceCount: 1,
-          unsEntryCount: 1,
-          quarantinedInstanceCount: 0,
-          engineErrorsCount: 0,
-          tickOverrunsCount: 0,
-          circuitBreakerTripsCount: 0,
-          uptimeMs: 0,
-          actualTicksPerSecond: 1,
-        },
-      }),
-      getState: () => snapshot,
-    },
-    setState(state: EngineCoreMetrics["state"]) {
-      runtime.state = state;
-    },
-    setTickCount(tickCount: number) {
-      runtime.tickCount = tickCount;
-    },
-    setLastTickProgressAt(timestamp: number) {
-      runtime.lastTickProgressAt = timestamp;
-    },
-    getLastTickProgressAt() {
-      return runtime.lastTickProgressAt;
-    },
-  };
-}
-
-function serverBaseUrl(endpoint: string): string {
-  const url = new URL(endpoint);
-  return `http://127.0.0.1:${url.port}`;
-}
-
-interface StartServerOptions {
-  readonly state: EngineCoreMetrics["state"];
-  readonly tickIntervalMs?: number;
-  readonly mqttEnabled: boolean;
-  readonly isMqttConnected: () => boolean;
-}
-
-function startTestServer(options: StartServerOptions, handles: Array<{ stop: () => void }>) {
-  const mock = createMockHealthEngine(options.state, options.tickIntervalMs ?? 1000);
-  const handle = startHealthServer({
-    engine: mock.engine,
-    host: "127.0.0.1",
-    port: 0,
-    mqttEnabled: options.mqttEnabled,
-    isMqttConnected: options.isMqttConnected,
-    getLastTickProgressAt: () => mock.getLastTickProgressAt(),
-  });
-  handles.push(handle);
-  const baseUrl = serverBaseUrl(handle.endpoint);
-  return { mock, baseUrl };
-}
-
-describe("health server", () => {
-  const handles: Array<{ stop: () => void }> = [];
-
-  afterEach(() => {
-    for (const handle of handles) {
-      handle.stop();
-    }
-    handles.length = 0;
-  });
-
-  test.each([
-    {
-      label: "200 when running and mqtt connected",
-      state: "running" as const,
-      healthStatus: 200,
-      readyStatus: 200,
-    },
-    { label: "503 when paused", state: "paused" as const, healthStatus: 200, readyStatus: 503 },
-  ])("/readyz returns $label", async ({ state, healthStatus, readyStatus }) => {
-    const { baseUrl } = startTestServer(
-      { state, mqttEnabled: true, isMqttConnected: () => true },
-      handles,
-    );
-
-    const health = await fetch(`${baseUrl}/healthz`);
-    const ready = await fetch(`${baseUrl}/readyz`);
-
-    expect(health.status).toBe(healthStatus);
-    expect(ready.status).toBe(readyStatus);
-  });
-
-  test("/readyz returns 503 when mqtt is enabled but disconnected", async () => {
-    const { baseUrl } = startTestServer(
-      { state: "running", mqttEnabled: true, isMqttConnected: () => false },
-      handles,
-    );
-
-    const ready = await fetch(`${baseUrl}/readyz`);
-    expect(ready.status).toBe(503);
-  });
-
-  test("/readyz ignores mqtt when mqtt is disabled", async () => {
-    const { baseUrl } = startTestServer(
-      { state: "running", mqttEnabled: false, isMqttConnected: () => false },
-      handles,
-    );
-
-    const ready = await fetch(`${baseUrl}/readyz`);
-    expect(ready.status).toBe(200);
-  });
-
-  test("/healthz returns 503 when state is stopped", async () => {
-    const { baseUrl } = startTestServer(
-      { state: "stopped", mqttEnabled: false, isMqttConnected: () => false },
-      handles,
-    );
-
-    const health = await fetch(`${baseUrl}/healthz`);
-    expect(health.status).toBe(503);
-  });
-
-  test("/healthz returns 503 on the first probe after running tick loop stalls", async () => {
-    const { mock, baseUrl } = startTestServer(
-      { state: "running", mqttEnabled: false, isMqttConnected: () => false },
-      handles,
-    );
-    mock.setLastTickProgressAt(Date.now() - 3_500);
-
-    const stalled = await fetch(`${baseUrl}/healthz`);
-    expect(stalled.status).toBe(503);
-
-    mock.setLastTickProgressAt(Date.now());
-    mock.setTickCount(1);
-    const recovered = await fetch(`${baseUrl}/healthz`);
-    expect(recovered.status).toBe(200);
-  });
-});

package/src/lib/health-server.ts

@@ -1,154 +0,0 @@
-import type { EngineCoreMetrics, EngineStateSnapshot } from "@miravo/core";
-
-interface HealthEngine {
-  getMetrics(): { readonly core: EngineCoreMetrics };
-  getState(): EngineStateSnapshot;
-}
-
-interface HealthServerOptions {
-  readonly engine: HealthEngine;
-  readonly host: string;
-  readonly port: number;
-  readonly mqttEnabled: boolean;
-  readonly isMqttConnected: () => boolean;
-  readonly getLastTickProgressAt: () => number;
-}
-
-interface HealthServerStatus {
-  readonly status: "ok" | "fail";
-  readonly reason?: string;
-}
-
-interface HealthServerHandle {
-  readonly endpoint: string;
-  stop(): void;
-}
-
-interface HealthResponseBody {
-  readonly status: "ok" | "fail";
-  readonly simulationState: EngineCoreMetrics["state"];
-  readonly tickCount: number;
-  readonly mqttEnabled: boolean;
-  readonly mqttConnected: boolean | null;
-  readonly stalled: boolean;
-  readonly reason?: string;
-}
-
-function toJsonResponse(body: HealthResponseBody, status: number): Response {
-  return new Response(JSON.stringify(body), {
-    status,
-    headers: {
-      "content-type": "application/json; charset=utf-8",
-      "cache-control": "no-store",
-    },
-  });
-}
-
-function livenessStatus(input: {
-  readonly core: EngineCoreMetrics;
-  readonly stalled: boolean;
-}): HealthServerStatus {
-  if (input.core.state === "stopped") {
-    return { status: "fail", reason: 'engine state is "stopped"' };
-  }
-  if (input.stalled) {
-    return { status: "fail", reason: "tick loop stalled" };
-  }
-  return { status: "ok" };
-}
-
-function readinessStatus(input: {
-  readonly core: EngineCoreMetrics;
-  readonly stalled: boolean;
-  readonly mqttEnabled: boolean;
-  readonly mqttConnected: boolean;
-}): HealthServerStatus {
-  if (input.core.state !== "running") {
-    return { status: "fail", reason: `engine state is "${input.core.state}"` };
-  }
-  if (input.stalled) {
-    return { status: "fail", reason: "tick loop stalled" };
-  }
-  if (input.mqttEnabled && !input.mqttConnected) {
-    return { status: "fail", reason: "mqtt disconnected" };
-  }
-  return { status: "ok" };
-}
-
-/**
- * Start a lightweight HTTP health server for container probes.
- *
- * - `/healthz`: liveness (process/tick loop health)
- * - `/readyz`: readiness (engine running + MQTT connected when enabled)
- */
-function startHealthServer(options: HealthServerOptions): HealthServerHandle {
-  const { engine, host, port, mqttEnabled, isMqttConnected, getLastTickProgressAt } = options;
-
-  const server = Bun.serve({
-    hostname: host,
-    port,
-    fetch(request) {
-      const pathname = new URL(request.url).pathname;
-      const metrics = engine.getMetrics();
-      const state = engine.getState();
-
-      const now = Date.now();
-      const stallThresholdMs = Math.max(100, state.config.tickIntervalMs * 3);
-      const lastTickProgressAt = getLastTickProgressAt();
-      const stalled =
-        metrics.core.state === "running" &&
-        Number.isFinite(lastTickProgressAt) &&
-        now - lastTickProgressAt > stallThresholdMs;
-
-      const mqttConnected = mqttEnabled ? isMqttConnected() : false;
-      const bodyBase = {
-        simulationState: metrics.core.state,
-        tickCount: metrics.core.tickCount,
-        mqttEnabled,
-        mqttConnected: mqttEnabled ? mqttConnected : null,
-        stalled,
-      } as const;
-
-      if (pathname === "/healthz") {
-        const status = livenessStatus({ core: metrics.core, stalled });
-        return toJsonResponse(
-          {
-            status: status.status,
-            ...bodyBase,
-            ...(status.reason ? { reason: status.reason } : {}),
-          },
-          status.status === "ok" ? 200 : 503,
-        );
-      }
-
-      if (pathname === "/readyz") {
-        const status = readinessStatus({
-          core: metrics.core,
-          stalled,
-          mqttEnabled,
-          mqttConnected,
-        });
-        return toJsonResponse(
-          {
-            status: status.status,
-            ...bodyBase,
-            ...(status.reason ? { reason: status.reason } : {}),
-          },
-          status.status === "ok" ? 200 : 503,
-        );
-      }
-
-      return new Response("Not Found", { status: 404 });
-    },
-  });
-
-  return {
-    endpoint: `http://${host}:${server.port}`,
-    stop() {
-      server.stop(true);
-    },
-  };
-}
-
-export { startHealthServer };
-export type { HealthEngine, HealthServerHandle, HealthServerOptions };