miravo 0.1.4 → 0.2.1

package/src/commands/status.test.ts

@@ -16,6 +16,7 @@ describe("miravo status", () => {
     expect(optionNames).toContain("--watch");
     expect(optionNames).toContain("--instance");
     expect(optionNames).toContain("--json");
+    expect(optionNames).toContain("--admin-url");
     expect(optionNames).toContain("--template");
   });
 
@@ -28,32 +29,12 @@ describe("miravo status", () => {
     expect(watchOpt?.short).toBe("-w");
   });
 
-  test("sets exit code 1 when no simulation is running", async () => {
+  test("sets exit code 1 with invalid admin URL", async () => {
     const { program } = await findCliCommand("status");
     program.exitOverride();
 
     try {
-      await program.parseAsync(["node", "miravo", "status"]);
-    } catch {
-      // Expected: connection error
-    }
-
-    // Should fail because no broker is running on default port
-    expect(process.exitCode).toBe(1);
-  });
-
-  test("sets exit code 1 with bad template path", async () => {
-    const { program } = await findCliCommand("status");
-    program.exitOverride();
-
-    try {
-      await program.parseAsync([
-        "node",
-        "miravo",
-        "status",
-        "--template",
-        "/nonexistent.miravo.yaml",
-      ]);
+      await program.parseAsync(["node", "miravo", "status", "--admin-url", "not-a-url"]);
     } catch {
       // Expected
     }

package/src/commands/status.ts

@@ -1,22 +1,25 @@
 import {
   CONTROL_STATUS_TIMEOUT_MS,
   type EngineMetricsSnapshot,
-  EngineMetricsSnapshotSchema,
   type EngineStateSnapshot,
-  EngineStateSnapshotSchema,
+  MiravoError,
 } from "@miravo/shared";
 import type { Command } from "commander";
 import { colors } from "consola/utils";
-import type { IPublishPacket, MqttClient } from "mqtt";
+import { getAdminSnapshot, resolveAdminUrl } from "../lib/admin-client.ts";
 import { connectToBroker, disconnectClient } from "../lib/mqtt-client.ts";
 import { parseDurationMs } from "../lib/parse.ts";
-import {
-  discoverRunningSimulations,
-  resolveTargetSimulation,
-  type SimulationTopics,
-} from "../lib/resolve-simulation.ts";
+import { discoverRunningSimulations } from "../lib/resolve-simulation.ts";
 import { engineLog, handleCommandError, isPlain, writeOutput } from "../logger.ts";
-import { formatCount, formatDuration, formatKeyValue, formatTable } from "../output.ts";
+import {
+  formatCount,
+  formatDuration,
+  formatHealthSuffix,
+  formatKeyValue,
+  formatTable,
+} from "../output.ts";
+
+const STATUS_WATCH_INTERVAL_MS = 1000;
 
 interface StatusOptions {
   readonly name?: string;
@@ -24,13 +27,14 @@ interface StatusOptions {
   readonly watch?: boolean;
   readonly instance?: string;
   readonly json?: boolean;
+  readonly adminUrl?: string;
   readonly template?: string;
   readonly timeout?: number;
 }
 
 /**
  * Register the `miravo status` command with the root Commander program.
- * Shows status of a running simulation via the MQTT control plane.
+ * Shows status of a running simulation via the admin HTTP server.
  */
 export function registerStatusCommand(program: Command): void {
   program
@@ -38,16 +42,17 @@ export function registerStatusCommand(program: Command): void {
     .description("Show status of a running simulation")
     .option("--name <name>", "Target simulation name")
     .option("--discover", "Discover running simulations and exit")
-    .option("-w, --watch", "Stay subscribed and re-render on updates")
+    .option("-w, --watch", "Poll the admin server and re-render on updates")
     .option("--instance <id>", "Show detailed status for one instance")
     .option("--json", "Machine-readable JSON output")
+    .option("--admin-url <url>", "Miravo admin server URL (env: MIRAVO_ADMIN_URL)")
     .option(
       "--template <path>",
-      "Path to .miravo.yaml for broker connection info (env: MIRAVO_TEMPLATE)",
+      "Path to .miravo.yaml for MQTT discovery connection info (env: MIRAVO_TEMPLATE)",
     )
     .option(
       "--timeout <ms>",
-      "Connection/data timeout in milliseconds (default: 5000)",
+      "Admin request timeout in milliseconds (default: 5000)",
       parseDurationMs,
     )
     .action(async (options: StatusOptions) => {
@@ -55,93 +60,70 @@ export function registerStatusCommand(program: Command): void {
     });
 }
 
-// ---------------------------------------------------------------------------
-// Types for parsed control plane messages
-// ---------------------------------------------------------------------------
-
 type MetricsSnapshot = EngineMetricsSnapshot;
 type StateSnapshot = EngineStateSnapshot;
 
-function parseMetricsSnapshot(payload: unknown): MetricsSnapshot | null {
-  const parsed = EngineMetricsSnapshotSchema.safeParse(payload);
-  return parsed.success ? (parsed.data as MetricsSnapshot) : null;
-}
-
-function parseStateSnapshot(payload: unknown): StateSnapshot | null {
-  const parsed = EngineStateSnapshotSchema.safeParse(payload);
-  return parsed.success ? (parsed.data as StateSnapshot) : null;
-}
-
 // ---------------------------------------------------------------------------
 // Action
 // ---------------------------------------------------------------------------
 
 async function statusAction(options: StatusOptions): Promise<void> {
   try {
-    const templateOption = options.template ?? Bun.env["MIRAVO_TEMPLATE"];
     const timeoutMs = options.timeout ?? CONTROL_STATUS_TIMEOUT_MS;
-    const { client, brokerInfo } = await connectToBroker(templateOption, timeoutMs);
-
-    try {
-      if (options.discover) {
-        const simulations = await discoverRunningSimulations(client, {
-          timeoutMs,
-          brokerUrl: brokerInfo.url,
-        });
-        if (simulations.length === 0) {
-          engineLog.error(
-            `No running simulations found on broker ${brokerInfo.url}. Start one with 'miravo start'.`,
-          );
-          process.exitCode = 1;
-          return;
-        }
-        writeOutput(`Found ${simulations.length} simulation(s):`);
-        for (const simulationName of simulations) {
-          writeOutput(`  ${simulationName}`);
-        }
-        return;
-      }
-
-      const target = await resolveTargetSimulation(client, {
-        timeoutMs,
-        brokerUrl: brokerInfo.url,
-        ...(options.name !== undefined ? { name: options.name } : {}),
-      });
+    if (options.discover) {
+      await discoverMode(options, timeoutMs);
+      return;
+    }
 
-      if (options.watch) {
-        await watchMode(client, options, timeoutMs, target);
-      } else {
-        await snapshotMode(client, brokerInfo.url, options, timeoutMs, target);
-      }
-    } finally {
-      if (!options.watch) {
-        disconnectClient(client);
-      }
+    const adminUrl = resolveAdminUrl(options.adminUrl);
+    if (options.watch) {
+      await watchMode(adminUrl, options, timeoutMs);
+    } else {
+      await snapshotMode(adminUrl, options, timeoutMs);
     }
   } catch (error) {
     handleCommandError(error, engineLog);
   }
 }
 
+// ---------------------------------------------------------------------------
+// Discover mode (MQTT-only)
+// ---------------------------------------------------------------------------
+
+async function discoverMode(options: StatusOptions, timeoutMs: number): Promise<void> {
+  const templateOption = options.template ?? Bun.env["MIRAVO_TEMPLATE"];
+  const { client, brokerInfo } = await connectToBroker(templateOption, timeoutMs);
+  try {
+    const simulations = await discoverRunningSimulations(client, {
+      timeoutMs,
+      brokerUrl: brokerInfo.url,
+    });
+    if (simulations.length === 0) {
+      engineLog.error(
+        `No running simulations found on broker ${brokerInfo.url}. Start one with 'miravo start'.`,
+      );
+      process.exitCode = 1;
+      return;
+    }
+    writeOutput(`Found ${simulations.length} simulation(s):`);
+    for (const simulationName of simulations) {
+      writeOutput(`  ${simulationName}`);
+    }
+  } finally {
+    disconnectClient(client);
+  }
+}
+
 // ---------------------------------------------------------------------------
 // Snapshot mode (default): get one reading and exit
 // ---------------------------------------------------------------------------
 
 async function snapshotMode(
-  client: MqttClient,
-  brokerUrl: string,
+  adminUrl: string,
   options: StatusOptions,
   timeoutMs: number,
-  target: { readonly simulationName: string; readonly topics: SimulationTopics },
 ): Promise<void> {
-  const data = await waitForData(
-    client,
-    brokerUrl,
-    timeoutMs,
-    target.topics,
-    target.simulationName,
-  );
-  if (!data) return;
+  const data = await getStatusSnapshot(adminUrl, timeoutMs, options.name);
 
   if (options.json) {
     const filtered = filterForJson(data.metrics, data.state, options.instance);
@@ -164,79 +146,33 @@ async function snapshotMode(
 // ---------------------------------------------------------------------------
 
 async function watchMode(
-  client: MqttClient,
+  adminUrl: string,
   options: StatusOptions,
   timeoutMs: number,
-  target: { readonly simulationName: string; readonly topics: SimulationTopics },
 ): Promise<void> {
-  let latestMetrics: MetricsSnapshot | null = null;
-  let latestState: StateSnapshot | null = null;
   let firstRender = true;
+  let stopped = false;
+  const stop = (): void => {
+    stopped = true;
+  };
 
-  // Subscribe to both topics
-  client.subscribe(target.topics.metrics, { qos: 0 });
-  client.subscribe(target.topics.state, { qos: 0 });
-
-  // Wait for initial data
-  const initial = await waitForDataFromSubscribed(client, timeoutMs, target.topics);
-  if (!initial) {
-    disconnectClient(client);
-    return;
-  }
+  process.once("SIGINT", stop);
+  process.once("SIGTERM", stop);
 
-  latestMetrics = initial.metrics;
-  latestState = initial.state;
-
-  // Render initial
-  renderFrame(latestMetrics, latestState, options, firstRender);
-  firstRender = false;
-
-  const onMessage = (topic: string, message: Buffer): void => {
-    try {
-      const parsed = JSON.parse(message.toString()) as unknown;
-      if (topic === target.topics.metrics) {
-        const metrics = parseMetricsSnapshot(parsed);
-        if (!metrics) return;
-        latestMetrics = metrics;
-      } else if (topic === target.topics.state) {
-        const state = parseStateSnapshot(parsed);
-        if (!state) return;
-        latestState = state;
-      } else {
-        return;
-      }
+  try {
+    while (!stopped) {
+      const snapshot = await getStatusSnapshot(adminUrl, timeoutMs, options.name);
+      renderFrame(snapshot.metrics, snapshot.state, options, firstRender);
+      firstRender = false;
 
-      if (latestMetrics && latestState) {
-        renderFrame(latestMetrics, latestState, options, firstRender);
-        firstRender = false;
+      if (!stopped) {
+        await Bun.sleep(STATUS_WATCH_INTERVAL_MS);
       }
-    } catch {
-      // Ignore parse errors in watch mode
     }
-  };
-
-  // Set up clean shutdown
-  let cleaned = false;
-  const cleanup = (): void => {
-    if (cleaned) return;
-    cleaned = true;
-    client.off("message", onMessage);
-    client.off("close", cleanup);
-    client.unsubscribe(target.topics.metrics);
-    client.unsubscribe(target.topics.state);
-    process.off("SIGINT", cleanup);
-    process.off("SIGTERM", cleanup);
-    disconnectClient(client);
-    const code =
-      typeof process.exitCode === "number" && process.exitCode !== 0 ? process.exitCode : 0;
-    process.exit(code);
-  };
-  process.once("SIGINT", cleanup);
-  process.once("SIGTERM", cleanup);
-  client.on("close", cleanup);
-
-  // Continue rendering on each new message
-  client.on("message", onMessage);
+  } finally {
+    process.off("SIGINT", stop);
+    process.off("SIGTERM", stop);
+  }
 }
 
 function renderFrame(
@@ -305,143 +241,19 @@ function filterForJson(
   };
 }
 
-// ---------------------------------------------------------------------------
-// Wait for initial data from control plane
-// ---------------------------------------------------------------------------
-
-interface ControlPlaneData {
-  readonly metrics: MetricsSnapshot;
-  readonly state: StateSnapshot;
-}
-
-interface WaitForDataOptions {
-  readonly client: MqttClient;
-  readonly timeoutMs: number;
-  readonly topics: SimulationTopics;
-  /** Error message shown when timeout expires. */
-  readonly timeoutMessage: string;
-  /** When true, subscribe/unsubscribe to control topics. When false, caller manages subscriptions. */
-  readonly manageSubscriptions: boolean;
-}
-
-function waitForData(
-  client: MqttClient,
-  brokerUrl: string,
+async function getStatusSnapshot(
+  adminUrl: string,
   timeoutMs: number,
-  topics: SimulationTopics,
-  simulationName: string,
-): Promise<ControlPlaneData | null> {
-  return waitForControlPlaneData({
-    client,
-    timeoutMs,
-    topics,
-    timeoutMessage: `No control-plane data received for simulation "${simulationName}" on ${brokerUrl}. Verify the simulation is running and publish permissions are enabled.`,
-    manageSubscriptions: true,
-  });
-}
-
-function waitForDataFromSubscribed(
-  client: MqttClient,
-  timeoutMs: number,
-  topics: SimulationTopics,
-): Promise<ControlPlaneData | null> {
-  return waitForControlPlaneData({
-    client,
-    timeoutMs,
-    topics,
-    timeoutMessage: "No data received from simulation. Is the control plane active?",
-    manageSubscriptions: false,
-  });
-}
-
-function waitForControlPlaneData(opts: WaitForDataOptions): Promise<ControlPlaneData | null> {
-  const { client, timeoutMs, timeoutMessage, manageSubscriptions, topics } = opts;
-
-  return new Promise((resolve) => {
-    let metrics: MetricsSnapshot | null = null;
-    let metricsFromRetained = false;
-    let state: StateSnapshot | null = null;
-    let stateFromRetained = false;
-    let retainedFallbackTimer: ReturnType<typeof setTimeout> | null = null;
-    let settled = false;
-
-    const retainedFallbackMs = Math.max(100, Math.min(750, Math.floor(timeoutMs / 4)));
-
-    const cleanup = (): void => {
-      clearTimeout(timer);
-      if (retainedFallbackTimer) {
-        clearTimeout(retainedFallbackTimer);
-        retainedFallbackTimer = null;
-      }
-      client.off("message", handler);
-      if (manageSubscriptions) {
-        client.unsubscribe(topics.metrics);
-        client.unsubscribe(topics.state);
-      }
-    };
-
-    const settle = (value: ControlPlaneData | null): void => {
-      if (settled) return;
-      settled = true;
-      cleanup();
-      resolve(value);
-    };
-
-    const maybeResolve = (): void => {
-      if (!metrics || !state) return;
-
-      if (!metricsFromRetained && !stateFromRetained) {
-        settle({ metrics, state });
-        return;
-      }
-
-      if (retainedFallbackTimer) return;
-
-      // Prefer fresh non-retained payloads when available, but don't block
-      // indefinitely if only retained snapshots are present.
-      retainedFallbackTimer = setTimeout(() => {
-        if (metrics && state) {
-          settle({ metrics, state });
-        }
-      }, retainedFallbackMs);
-    };
-
-    const timer = setTimeout(() => {
-      if (settled) return;
-      settled = true;
-      cleanup();
-      engineLog.error(timeoutMessage);
-      process.exitCode = 1;
-      resolve(null);
-    }, timeoutMs);
-
-    const handler = (topic: string, message: Buffer, packet: IPublishPacket): void => {
-      try {
-        const parsed = JSON.parse(message.toString()) as unknown;
-        if (topic === topics.metrics && (!metrics || metricsFromRetained)) {
-          const validMetrics = parseMetricsSnapshot(parsed);
-          if (!validMetrics) return;
-          metrics = validMetrics;
-          metricsFromRetained = packet.retain;
-        } else if (topic === topics.state && (!state || stateFromRetained)) {
-          const validState = parseStateSnapshot(parsed);
-          if (!validState) return;
-          state = validState;
-          stateFromRetained = packet.retain;
-        }
-
-        maybeResolve();
-      } catch {
-        // Ignore parse errors, wait for valid data
-      }
-    };
-
-    if (manageSubscriptions) {
-      client.subscribe(topics.metrics, { qos: 0 });
-      client.subscribe(topics.state, { qos: 0 });
-    }
-    client.on("message", handler);
-  });
+  expectedName?: string,
+): Promise<{ readonly metrics: MetricsSnapshot; readonly state: StateSnapshot }> {
+  const snapshot = await getAdminSnapshot(adminUrl, timeoutMs);
+  if (expectedName && snapshot.state.simulationName !== expectedName) {
+    throw new MiravoError(
+      `Connected to simulation "${snapshot.state.simulationName}" instead of "${expectedName}".`,
+      "Pass --admin-url for the correct Miravo process, or omit --name to inspect the connected simulation.",
+    );
+  }
+  return snapshot;
 }
 
 // ---------------------------------------------------------------------------
@@ -462,7 +274,8 @@ function renderOverview(metrics: MetricsSnapshot, state: StateSnapshot): void {
   // Engine line
   const stateColor =
     core.state === "running" ? colors.green : core.state === "paused" ? colors.yellow : colors.red;
-  const tps = core.actualTicksPerSecond > 0 ? `${core.actualTicksPerSecond.toFixed(1)} tps` : "";
+  const tps =
+    core.actualTicksPerSecond > 0 ? `${core.actualTicksPerSecond.toFixed(1)} ticks/s` : "";
 
   writeOutput(
     formatKeyValue([
@@ -472,7 +285,7 @@ function renderOverview(metrics: MetricsSnapshot, state: StateSnapshot): void {
       ],
       [
         colors.dim("Fleet"),
-        `${colors.bold(String(core.instanceCount))} instances${sep}${colors.bold(String(core.unsEntryCount))} UNS topics`,
+        `${colors.bold(String(core.instanceCount))} instances${sep}${colors.bold(String(core.memberValueCount))} data points`,
       ],
     ]),
   );
@@ -513,11 +326,33 @@ function renderOverview(metrics: MetricsSnapshot, state: StateSnapshot): void {
       mqttAdapter.metrics.errorsCount > 0
         ? colors.yellow(String(mqttAdapter.metrics.errorsCount))
         : colors.green("0");
+    const healthStr = formatHealthSuffix(mqttAdapter.metrics, sep);
     writeOutput(
       formatKeyValue([
         [
           colors.dim("MQTT"),
-          `${connStr}${sep}${formatCount(mqttAdapter.metrics.messagesPublished)} published${sep}${errStr} errors`,
+          `${connStr}${sep}${formatCount(mqttAdapter.metrics.messagesPublished)} published${sep}${errStr} errors${healthStr}`,
+        ],
+      ]),
+    );
+  }
+
+  // OPC UA
+  const opcuaAdapter = metrics.adapters.find((a) => a.name === "opcua");
+  if (opcuaAdapter) {
+    const connStr = opcuaAdapter.metrics.connected
+      ? colors.green("connected")
+      : colors.red("disconnected");
+    const errStr =
+      opcuaAdapter.metrics.errorsCount > 0
+        ? colors.yellow(String(opcuaAdapter.metrics.errorsCount))
+        : colors.green("0");
+    const healthStr = formatHealthSuffix(opcuaAdapter.metrics, sep);
+    writeOutput(
+      formatKeyValue([
+        [
+          colors.dim("OPC UA"),
+          `${connStr}${sep}${formatCount(opcuaAdapter.metrics.messagesPublished)} updates${sep}${errStr} errors${healthStr}`,
         ],
       ]),
     );
@@ -601,7 +436,7 @@ function renderInstanceDetail(
 
   writeOutput(
     formatKeyValue([
-      [colors.dim("UNS Path"), instance.unsPath],
+      [colors.dim("UNS Path"), instance.browsePath.join("/")],
       [
         colors.dim("Lifecycle"),
         `${instance.lifecycleStage} (${formatCount(Math.floor(instance.operatingHours))} operating hours)`,

package/src/commands/templates.test.ts

@@ -1,20 +1,16 @@
 import { afterEach, beforeEach, describe, expect, test } from "bun:test";
-import { mkdir } from "node:fs/promises";
 import { resolve } from "node:path";
 import { loadTemplate } from "@miravo/core";
 import { createTmpFileUtils } from "@miravo/core/test-tmp-utils";
-import { MIRAVO_CONTENT_DIR_ENV } from "@miravo/shared";
 import { stripAnsi } from "consola/utils";
 import { configureLogger } from "../logger.ts";
-import { runCliCommand, withEnvVar } from "./cli-test-setup.ts";
+import { runCliCommand } from "./cli-test-setup.ts";
 import { formatTemplateInspect } from "./templates.ts";
 
 configureLogger({ silent: true });
 
-const templatesDir = resolve(import.meta.dir, "..", "..", "..", "..", "templates");
-const { tmpDir, cleanupTmpDir } = createTmpFileUtils(
-  resolve(import.meta.dir, ".tmp-test-templates"),
-);
+const templatesDir = resolve(import.meta.dir, "..", "..", "..", "content", "templates");
+const { cleanupTmpDir } = createTmpFileUtils(resolve(import.meta.dir, ".tmp-test-templates"));
 
 beforeEach(() => {
   process.exitCode = 0;
@@ -34,7 +30,7 @@ describe("formatTemplateInspect", () => {
     const output = stripAnsi(raw);
 
     expect(output).toContain("Smart Factory Production Line");
-    expect(output).toContain("built-in (templates/smart-factory.miravo.yaml)");
+    expect(output).toContain("built-in");
     expect(output).toContain("Template ID:");
     expect(output).toContain("smart-factory");
     expect(output).toContain("Namespace:");
@@ -68,48 +64,6 @@ describe("miravo templates", () => {
     expect(process.exitCode).toBe(0);
   });
 
-  test("templates inspect --copy copies template and referenced built-in models", async () => {
-    await withEnvVar(MIRAVO_CONTENT_DIR_ENV, tmpDir, async () => {
-      await runCliCommand(["templates", "inspect", "smart-factory", "--copy"]);
-
-      expect(process.exitCode).toBe(0);
-
-      const copiedTemplatePath = resolve(tmpDir, "templates", "smart-factory.miravo.yaml");
-      expect(await Bun.file(copiedTemplatePath).exists()).toBe(true);
-
-      const copiedTemplate = await loadTemplate(copiedTemplatePath);
-      const inlineModels = new Set((copiedTemplate.models ?? []).map((model) => model.name));
-      const referencedModels = new Set<string>();
-      for (const area of copiedTemplate.areas) {
-        for (const line of area.lines) {
-          for (const twin of line.twins) {
-            referencedModels.add(twin.model);
-          }
-        }
-      }
-
-      for (const modelName of referencedModels) {
-        if (inlineModels.has(modelName)) continue;
-        const copiedModelPath = resolve(tmpDir, "models", `${modelName}.twin.yaml`);
-        expect(await Bun.file(copiedModelPath).exists()).toBe(true);
-      }
-    });
-  });
-
-  test("templates inspect --copy skips existing files with a message", async () => {
-    const targetPath = resolve(tmpDir, "templates", "smart-factory.miravo.yaml");
-    await mkdir(resolve(tmpDir, "templates"), { recursive: true });
-    const dummyContent = `kind: MiravoTemplate\nversion: "1"\nname: keep-existing\nnamespace:\n  prefix: test\nareas:\n  - name: a\n    lines:\n      - name: l\n        twins:\n          - model: m\n            count: 1\n`;
-    await Bun.write(targetPath, dummyContent);
-
-    await withEnvVar(MIRAVO_CONTENT_DIR_ENV, tmpDir, async () => {
-      await runCliCommand(["templates", "inspect", "smart-factory", "--copy"]);
-
-      expect(process.exitCode).toBe(0);
-      expect(await Bun.file(targetPath).text()).toContain("name: keep-existing");
-    });
-  });
-
   test("templates list with bad directory sets exit code 1", async () => {
     await runCliCommand(["templates", "list", "--dir", "/nonexistent/templates-dir"]);
     expect(process.exitCode).toBe(1);