miravo 0.3.0 → 0.5.0

package/src/commands/start.ts

@@ -9,9 +9,11 @@ import {
   discoverTemplates,
   loadTemplate,
   loadTwinModel,
+  resolveMiravoHome,
   resolveModelPath,
   validateFullTemplate,
 } from "@miravo/core";
+import { ModbusAdapter } from "@miravo/modbus";
 import { MQTTAdapter } from "@miravo/mqtt";
 import { OPCUAAdapter } from "@miravo/opcua";
 import type {
@@ -24,6 +26,7 @@ import type {
 import {
   ConfigNotFoundError,
   ConfigValidationError,
+  DEFAULT_MODBUS_PORT,
   DEFAULT_MQTT_PORT,
   DEFAULT_OPCUA_PORT,
   DEFAULT_TICK_INTERVAL_MS,
@@ -31,10 +34,12 @@ import {
   MIRAVO_VERSION,
   MiravoError,
   MiravoTemplateSchema,
+  PersistedStateSchema,
   SimulationNameSchema,
   TWIN_FILE_EXTENSION,
   TwinModelSchema,
 } from "@miravo/shared";
+import { Glob } from "bun";
 import type { Command } from "commander";
 import { box, colors, stripAnsi } from "consola/utils";
 import { parse as parseYAML } from "yaml";
@@ -77,6 +82,7 @@ import {
   handleCommandError,
   isPlain,
   lifecycleLog,
+  modbusLog,
   mqttLog,
   opcuaLog,
   setRuntimeLogContext,
@@ -101,6 +107,9 @@ interface StartOptions {
   readonly opcuaPort?: number;
   readonly opcuaHost?: string;
   readonly opcua?: boolean;
+  readonly modbusPort?: number;
+  readonly modbusHost?: string;
+  readonly modbus?: boolean;
   readonly adminHost?: string;
   readonly adminPort?: number;
   readonly dryRun?: boolean;
@@ -118,7 +127,7 @@ interface RestoreSummary {
 }
 
 interface ProtocolBootPlan {
-  readonly name: "mqtt" | "opcua";
+  readonly name: "mqtt" | "opcua" | "modbus";
   readonly shouldEnable: boolean;
   readonly overrideRestore: boolean;
 }
@@ -126,6 +135,7 @@ interface ProtocolBootPlan {
 type ProtocolOptionSource =
   | "mqtt"
   | "opcua"
+  | "modbus"
   | "mqttPort"
   | "mqttHost"
   | "mqttMode"
@@ -133,7 +143,9 @@ type ProtocolOptionSource =
   | "mqttUsername"
   | "mqttPassword"
   | "opcuaPort"
-  | "opcuaHost";
+  | "opcuaHost"
+  | "modbusPort"
+  | "modbusHost";
 
 type MqttMode = "embedded" | "external";
 
@@ -158,7 +170,12 @@ function resolveConsoleDir(): string | undefined {
     // @miravo/console not installed (npm/bunx) — fall through
   }
 
-  // 3. npm install / bunx: look for console-dist/ shipped inside the published package.
+  // 3. Docker / monorepo: workspace symlinks may not exist (production install).
+  //    start.ts is at packages/cli/src/commands/ → ../../../console/dist
+  const monorepo = resolve(import.meta.dir, "..", "..", "..", "console", "dist");
+  if (existsSync(`${monorepo}/index.html`)) return monorepo;
+
+  // 4. npm install / bunx: look for console-dist/ shipped inside the published package.
   //    start.ts is at packages/cli/src/commands/ → ../../console-dist/
   const shipped = resolve(import.meta.dir, "..", "..", "console-dist");
   if (existsSync(`${shipped}/index.html`)) return shipped;
@@ -215,6 +232,13 @@ export function registerStartCommand(program: Command): void {
       parsePort,
     )
     .option("--opcua-host <host>", "OPC UA server bind host (env: MIRAVO_OPCUA_HOST)")
+    .option("--modbus", "Enable Modbus TCP server adapter")
+    .option(
+      "--modbus-port <number>",
+      `Modbus TCP port (default: ${DEFAULT_MODBUS_PORT}, env: MIRAVO_MODBUS_PORT)`,
+      parsePort,
+    )
+    .option("--modbus-host <host>", "Modbus TCP bind host (env: MIRAVO_MODBUS_HOST)")
     .option("--admin-host <host>", "Admin server host (default: 127.0.0.1, env: MIRAVO_ADMIN_HOST)")
     .option(
       "--admin-port <number>",
@@ -274,6 +298,7 @@ async function startAction(options: StartOptions): Promise<void> {
     // Protocol selection: CLI flags decide which protocols run
     const mqttEnabled = options.mqtt !== false; // --no-mqtt disables
     const opcuaEnabled = options.opcua === true; // --opcua enables
+    const modbusEnabled = options.modbus === true; // --modbus enables
 
     // Warn on ignored protocol-specific flags
     if (!mqttEnabled) {
@@ -299,6 +324,18 @@ async function startAction(options: StartOptions): Promise<void> {
         );
       }
     }
+    if (!modbusEnabled) {
+      if (options.modbusPort !== undefined) {
+        configLog.warn(
+          "--modbus-port ignored because Modbus is not enabled. Use --modbus to enable it.",
+        );
+      }
+      if (options.modbusHost !== undefined) {
+        configLog.warn(
+          "--modbus-host ignored because Modbus is not enabled. Use --modbus to enable it.",
+        );
+      }
+    }
 
     const adminHost = options.adminHost ?? Bun.env["MIRAVO_ADMIN_HOST"] ?? "127.0.0.1";
     const adminPortEnv = Bun.env["MIRAVO_ADMIN_PORT"];
@@ -389,6 +426,30 @@ async function startAction(options: StartOptions): Promise<void> {
       }
     }
 
+    // Modbus env overrides — only parsed when Modbus is enabled
+    let modbusPort: number | undefined = options.modbusPort;
+    let modbusHost: string | undefined;
+    if (modbusEnabled) {
+      const modbusPortEnv = Bun.env["MIRAVO_MODBUS_PORT"];
+      if (modbusPort === undefined && modbusPortEnv) {
+        try {
+          modbusPort = parsePort(modbusPortEnv);
+        } catch {
+          throw new ConfigValidationError({
+            message: `Invalid MIRAVO_MODBUS_PORT environment variable: "${modbusPortEnv}".`,
+            fix: "Set MIRAVO_MODBUS_PORT to a valid port number between 0 and 65535.",
+          });
+        }
+      }
+      modbusHost = options.modbusHost ?? Bun.env["MIRAVO_MODBUS_HOST"] ?? undefined;
+      if (modbusHost !== undefined && modbusHost.trim().length === 0) {
+        throw new ConfigValidationError({
+          message: "Invalid Modbus TCP bind host: value is empty.",
+          fix: "Set --modbus-host / MIRAVO_MODBUS_HOST to a valid host (for example, 0.0.0.0 or 127.0.0.1).",
+        });
+      }
+    }
+
     let adminPort = options.adminPort;
     if (adminPort === undefined && adminPortEnv) {
       try {
@@ -403,7 +464,29 @@ async function startAction(options: StartOptions): Promise<void> {
     adminPort ??= 8080;
 
     // Step 1: Resolve template path(s)
-    const templatePath = await resolveTemplatePath(templateOption, catalog);
+    // If the simulation name is explicitly known and no template was given,
+    // peek at persisted state to recover the template path — skipping the
+    // interactive picker on resume.
+    let effectiveTemplateOption = templateOption;
+    if (!effectiveTemplateOption && !options.resetState) {
+      const knownName = options.name ?? simulationNameEnv;
+      if (knownName) {
+        // Named: peek by explicit simulation name
+        const peeked = await peekStateTemplatePath(knownName);
+        if (peeked) {
+          effectiveTemplateOption = peeked;
+          configLog.debug(`Resuming from persisted state: template=${peeked}`);
+        }
+      } else {
+        // Unnamed: scan state dir — auto-resume if exactly one simulation exists
+        const peeked = await peekSingleStateTemplatePath();
+        if (peeked) {
+          effectiveTemplateOption = peeked;
+          configLog.debug(`Resuming from persisted state: template=${peeked}`);
+        }
+      }
+    }
+    const templatePath = await resolveTemplatePath(effectiveTemplateOption, catalog);
     configLog.debug(`Resolved template: ${templatePath}`);
     // Resolve any additional comma-separated templates upfront so errors surface before engine start
     const extraTemplatePaths = await Promise.all(
@@ -432,6 +515,27 @@ async function startAction(options: StartOptions): Promise<void> {
 
     // Step 3b: Detach check — spawn background process and exit
     if (options.detach) {
+      const detachAdapterConfigs = resolveDetachAdapterConfigs({
+        template,
+        simulationName,
+        mqtt: {
+          enabled: mqttEnabled,
+          portOverride: portOption,
+          overrides: mqttOverrides,
+        },
+        opcua: {
+          enabled: opcuaEnabled,
+          portOverride: opcuaPort,
+          hostOverride: opcuaHost,
+          writeBudgetOverride: opcuaWriteBudget,
+        },
+        modbus: {
+          enabled: modbusEnabled,
+          portOverride: modbusPort,
+          hostOverride: modbusHost,
+        },
+      });
+
       await detachAction({
         simulationName,
         templatePath,
@@ -439,12 +543,16 @@ async function startAction(options: StartOptions): Promise<void> {
         seedExplicit,
         adminHost,
         adminPort,
-        mqttPort: options.mqttPort,
-        mqttHost: options.mqttHost,
+        mqttPort: detachAdapterConfigs.mqtt.port,
+        mqttHost: detachAdapterConfigs.mqtt.host,
+        mqttEmbedded: detachAdapterConfigs.mqtt.embedded,
         mqttEnabled,
-        opcuaPort,
-        opcuaHost,
+        opcuaPort: detachAdapterConfigs.opcua.port,
+        opcuaHost: detachAdapterConfigs.opcua.host,
         opcuaEnabled,
+        modbusPort: detachAdapterConfigs.modbus.port,
+        modbusHost: detachAdapterConfigs.modbus.host,
+        modbusEnabled,
       });
       return;
     }
@@ -565,6 +673,17 @@ async function startAction(options: StartOptions): Promise<void> {
       opcuaDefaultConfig,
     );
 
+    const modbusDefaultConfig = buildModbusDefaultConfig(template, modbusPort, modbusHost);
+    eng.registerAvailableAdapter(
+      "modbus",
+      async (config) => {
+        const adapter = new ModbusAdapter(eng.bus, eng);
+        await adapter.start(config);
+        return { adapter, endpoint: buildModbusEndpoint(config) };
+      },
+      modbusDefaultConfig,
+    );
+
     // Step 5b: Wire control plane (dynamically follows MQTT adapter lifecycle)
     function wireControlPlane(): void {
       // Stop old control plane before creating a new one (prevents listener leaks)
@@ -669,6 +788,8 @@ async function startAction(options: StartOptions): Promise<void> {
       availableAdapters.find((a) => a.name === "mqtt" && a.enabled)?.endpoint ?? null;
     const opcuaEndpoint =
       availableAdapters.find((a) => a.name === "opcua" && a.enabled)?.endpoint ?? null;
+    const modbusEndpoint =
+      availableAdapters.find((a) => a.name === "modbus" && a.enabled)?.endpoint ?? null;
     printStartupBanner(
       templatePath,
       eng,
@@ -676,6 +797,7 @@ async function startAction(options: StartOptions): Promise<void> {
       seedExplicit,
       mqttEndpoint,
       opcuaEndpoint,
+      modbusEndpoint,
       simulationName,
       runId,
       adminServer.endpoint,
@@ -729,10 +851,30 @@ interface DetachOptions {
   readonly adminPort: number;
   readonly mqttPort: number | undefined;
   readonly mqttHost: string | undefined;
+  readonly mqttEmbedded: boolean;
   readonly mqttEnabled: boolean;
   readonly opcuaPort: number | undefined;
   readonly opcuaHost: string | undefined;
   readonly opcuaEnabled: boolean;
+  readonly modbusPort: number | undefined;
+  readonly modbusHost: string | undefined;
+  readonly modbusEnabled: boolean;
+}
+
+interface ResolvedDetachAdapterConfigs {
+  readonly mqtt: {
+    readonly port: number | undefined;
+    readonly host: string | undefined;
+    readonly embedded: boolean;
+  };
+  readonly opcua: {
+    readonly port: number | undefined;
+    readonly host: string | undefined;
+  };
+  readonly modbus: {
+    readonly port: number | undefined;
+    readonly host: string | undefined;
+  };
 }
 
 async function detachAction(opts: DetachOptions): Promise<void> {
@@ -766,10 +908,11 @@ async function detachActionLocked(
   // 2. Check port conflicts
   const ports = new Map<string, number>();
   ports.set("admin", adminPort);
-  if (opts.mqttEnabled && opts.mqttPort) ports.set("mqtt", opts.mqttPort);
-  if (opts.mqttEnabled && !opts.mqttPort) ports.set("mqtt", DEFAULT_MQTT_PORT);
-  if (opts.opcuaEnabled && opts.opcuaPort) ports.set("opcua", opts.opcuaPort);
-  if (opts.opcuaEnabled && !opts.opcuaPort) ports.set("opcua", DEFAULT_OPCUA_PORT);
+  if (opts.mqttEnabled && opts.mqttEmbedded && opts.mqttPort !== undefined) {
+    ports.set("mqtt", opts.mqttPort);
+  }
+  if (opts.opcuaEnabled && opts.opcuaPort !== undefined) ports.set("opcua", opts.opcuaPort);
+  if (opts.modbusEnabled && opts.modbusPort !== undefined) ports.set("modbus", opts.modbusPort);
 
   const conflicts = await checkPortConflicts(ports);
   if (conflicts.length > 0) {
@@ -827,6 +970,10 @@ async function detachActionLocked(
     const opcuaPort = opts.opcuaPort ?? DEFAULT_OPCUA_PORT;
     adapters["opcua"] = { port: opcuaPort, host: opts.opcuaHost ?? "0.0.0.0" };
   }
+  if (opts.modbusEnabled) {
+    const modbusPort = opts.modbusPort ?? DEFAULT_MODBUS_PORT;
+    adapters["modbus"] = { port: modbusPort, host: opts.modbusHost ?? "0.0.0.0" };
+  }
 
   const entry: DaemonRegistryEntry = {
     name: simulationName,
@@ -930,6 +1077,8 @@ function printDetachSummary(entry: DaemonRegistryEntry): void {
       lines.push(`  MQTT      mqtt://${host}:${adapter.port}`);
     } else if (name === "opcua") {
       lines.push(`  OPC UA    opc.tcp://${host}:${adapter.port}`);
+    } else if (name === "modbus") {
+      lines.push(`  Modbus    modbus://${host}:${adapter.port}`);
     } else {
       lines.push(`  ${name}      ${host}:${adapter.port}`);
     }
@@ -946,6 +1095,47 @@ function printDetachSummary(entry: DaemonRegistryEntry): void {
 // Step 1: Template resolution
 // ---------------------------------------------------------------------------
 
+async function peekStateTemplatePath(simulationName: string): Promise<string | undefined> {
+  const stateDir = `${resolveMiravoHome()}/state`;
+  const file = Bun.file(`${stateDir}/${simulationName}.json`);
+  if (!(await file.exists())) return undefined;
+  try {
+    const parsed = JSON.parse(await file.text()) as unknown;
+    const result = PersistedStateSchema.safeParse(parsed);
+    if (!result.success) return undefined;
+    return result.data.templateRuns.find((r) => r.templatePath.trim().length > 0)?.templatePath;
+  } catch {
+    return undefined;
+  }
+}
+
+async function peekSingleStateTemplatePath(): Promise<string | undefined> {
+  const stateDir = `${resolveMiravoHome()}/state`;
+  let bestTemplatePath: string | undefined;
+  let bestSavedAt = "";
+  try {
+    const glob = new Glob("*.json");
+    for await (const file of glob.scan({ cwd: stateDir, onlyFiles: true })) {
+      try {
+        const parsed = JSON.parse(await Bun.file(`${stateDir}/${file}`).text()) as unknown;
+        const result = PersistedStateSchema.safeParse(parsed);
+        if (!result.success) continue;
+        const templatePath = result.data.templateRuns.find(
+          (r) => r.templatePath.trim().length > 0,
+        )?.templatePath;
+        if (!templatePath) continue;
+        if (result.data.savedAt > bestSavedAt) {
+          bestSavedAt = result.data.savedAt;
+          bestTemplatePath = templatePath;
+        }
+      } catch {}
+    }
+  } catch {
+    return undefined; // state dir doesn't exist yet (first-ever run)
+  }
+  return bestTemplatePath;
+}
+
 async function resolveTemplatePath(
   templateOption: string | undefined,
   catalog: ContentCatalog,
@@ -1217,6 +1407,9 @@ function createAndPopulateEngine(
           mqttPassword: getCommandOptionSource(options.command, "mqttPassword"),
           opcuaPort: getCommandOptionSource(options.command, "opcuaPort"),
           opcuaHost: getCommandOptionSource(options.command, "opcuaHost"),
+          modbus: getCommandOptionSource(options.command, "modbus"),
+          modbusPort: getCommandOptionSource(options.command, "modbusPort"),
+          modbusHost: getCommandOptionSource(options.command, "modbusHost"),
         },
         restoredFromPersistence,
       });
@@ -1251,6 +1444,7 @@ function createAndPopulateEngine(
       variation: twin.variation,
       unsBasePath,
       ...(twin.parameters !== undefined ? { parameterOverrides: twin.parameters } : {}),
+      ...(twin.starting_hours !== undefined ? { startingHours: twin.starting_hours } : {}),
       templateRunId: bootRunId,
     });
     for (const node of spawned) {
@@ -1357,6 +1551,7 @@ function createRuntimeTemplateLoader(
           variation: twin.variation,
           unsBasePath,
           ...(twin.parameters !== undefined ? { parameterOverrides: twin.parameters } : {}),
+          ...(twin.starting_hours !== undefined ? { startingHours: twin.starting_hours } : {}),
           templateRunId: runId,
         });
         for (const node of spawned) {
@@ -1565,6 +1760,23 @@ function buildOPCUAEndpoint(config: import("@miravo/shared").ProtocolConfig): st
   return `opc.tcp://${displayHost}:${port}`;
 }
 
+function buildModbusDefaultConfig(
+  template: MiravoTemplate,
+  portOverride: number | undefined,
+  hostOverride: string | undefined,
+): Record<string, unknown> {
+  const modbusConfig = template.protocols?.modbus;
+  const port = portOverride ?? modbusConfig?.port ?? DEFAULT_MODBUS_PORT;
+  const host = hostOverride ?? modbusConfig?.host ?? "0.0.0.0";
+  return { name: "modbus", enabled: true, port, host };
+}
+
+function buildModbusEndpoint(config: Record<string, unknown>): string {
+  const port = (config as { port?: number }).port ?? DEFAULT_MODBUS_PORT;
+  const host = (config as { host?: string }).host ?? "0.0.0.0";
+  return `modbus://${displayHost(String(host))}:${port}`;
+}
+
 // ---------------------------------------------------------------------------
 // Step 6: Startup banner
 // ---------------------------------------------------------------------------
@@ -1576,6 +1788,7 @@ function printStartupBanner(
   seedExplicit: boolean,
   mqttEndpoint: string | null,
   opcuaEndpoint: string | null,
+  modbusEndpoint: string | null,
   simulationName: string,
   runId: string,
   adminEndpoint: string,
@@ -1594,6 +1807,7 @@ function printStartupBanner(
 
   const mqttValue = mqttEndpoint ? colors.cyan(mqttEndpoint) : colors.dim("disabled");
   const opcuaValue = opcuaEndpoint ? colors.cyan(opcuaEndpoint) : colors.dim("disabled");
+  const modbusValue = modbusEndpoint ? colors.cyan(modbusEndpoint) : colors.dim("disabled");
 
   const allEntries: ReadonlyArray<readonly [string, string]> = [
     [colors.dim("Simulation"), colors.bold(simulationName)],
@@ -1603,6 +1817,7 @@ function printStartupBanner(
     [colors.dim("Instances"), colors.bold(String(state.instances.length))],
     [colors.dim("MQTT"), mqttValue],
     [colors.dim("OPC UA"), opcuaValue],
+    [colors.dim("Modbus"), modbusValue],
     [colors.dim("Admin"), colors.cyan(adminEndpoint)],
     [colors.dim("Tick interval"), colors.bold(`${state.config.tickIntervalMs}ms`)],
     [colors.dim("Time multiplier"), colors.bold(`${state.config.timeMultiplier}x`)],
@@ -1781,6 +1996,12 @@ export function resolveProtocolBootPlans(input: {
       (option) => input.optionSources[option as ProtocolOptionSource] === "cli",
     );
 
+  const modbusConfigExplicit =
+    input.options.modbus === true &&
+    ["modbusPort", "modbusHost"].some(
+      (option) => input.optionSources[option as ProtocolOptionSource] === "cli",
+    );
+
   return [
     {
       name: "mqtt",
@@ -1798,9 +2019,79 @@ export function resolveProtocolBootPlans(input: {
         input.optionSources["opcua"] === "cli" ||
         opcuaConfigExplicit,
     },
+    {
+      name: "modbus",
+      shouldEnable: input.options.modbus === true,
+      overrideRestore:
+        !input.restoredFromPersistence ||
+        input.optionSources["modbus"] === "cli" ||
+        modbusConfigExplicit,
+    },
   ];
 }
 
+export function resolveDetachAdapterConfigs(input: {
+  readonly template: MiravoTemplate;
+  readonly simulationName: string;
+  readonly mqtt: {
+    readonly enabled: boolean;
+    readonly portOverride: number | undefined;
+    readonly overrides: MqttRunOverrides;
+  };
+  readonly opcua: {
+    readonly enabled: boolean;
+    readonly portOverride: number | undefined;
+    readonly hostOverride: string | undefined;
+    readonly writeBudgetOverride: number | undefined;
+  };
+  readonly modbus: {
+    readonly enabled: boolean;
+    readonly portOverride: number | undefined;
+    readonly hostOverride: string | undefined;
+  };
+}): ResolvedDetachAdapterConfigs {
+  const mqttConfig = input.mqtt.enabled
+    ? buildMQTTDefaultConfig(
+        input.template,
+        input.mqtt.portOverride,
+        input.mqtt.overrides,
+        input.simulationName,
+      )
+    : null;
+  const opcuaConfig = input.opcua.enabled
+    ? buildOPCUADefaultConfig(
+        input.template,
+        input.opcua.portOverride,
+        input.opcua.hostOverride,
+        input.simulationName,
+        input.opcua.writeBudgetOverride,
+      )
+    : null;
+  const modbusConfig = input.modbus.enabled
+    ? buildModbusDefaultConfig(input.template, input.modbus.portOverride, input.modbus.hostOverride)
+    : null;
+
+  return {
+    mqtt: {
+      port: mqttConfig ? ((mqttConfig as { port?: number }).port ?? DEFAULT_MQTT_PORT) : undefined,
+      host: mqttConfig ? ((mqttConfig as { host?: string }).host ?? "127.0.0.1") : undefined,
+      embedded: mqttConfig ? ((mqttConfig as { embedded?: boolean }).embedded ?? true) : false,
+    },
+    opcua: {
+      port: opcuaConfig
+        ? ((opcuaConfig as { port?: number }).port ?? DEFAULT_OPCUA_PORT)
+        : undefined,
+      host: opcuaConfig ? ((opcuaConfig as { host?: string }).host ?? "0.0.0.0") : undefined,
+    },
+    modbus: {
+      port: modbusConfig
+        ? ((modbusConfig as { port?: number }).port ?? DEFAULT_MODBUS_PORT)
+        : undefined,
+      host: modbusConfig ? ((modbusConfig as { host?: string }).host ?? "0.0.0.0") : undefined,
+    },
+  };
+}
+
 async function reconcileProtocolBootPlan(engine: Engine, plan: ProtocolBootPlan): Promise<void> {
   const adapter = engine.getAvailableAdapters().find((candidate) => candidate.name === plan.name);
   const isEnabled = adapter?.enabled === true;
@@ -1853,6 +2144,13 @@ async function reconcileProtocolBootPlan(engine: Engine, plan: ProtocolBootPlan)
     return;
   }
 
+  if (plan.name === "modbus") {
+    modbusLog.ready(
+      `server ready · endpoint: ${colors.cyan(String((result.data as Record<string, unknown>)?.["endpoint"] ?? ""))}`,
+    );
+    return;
+  }
+
   opcuaLog.ready(
     `server ready · endpoint: ${colors.cyan(String((result.data as Record<string, unknown>)?.["endpoint"] ?? ""))}`,
   );

package/src/commands/status.test.ts

@@ -5,32 +5,6 @@ beforeEach(resetExitCode);
 afterEach(resetExitCode);
 
 describe("miravo status", () => {
-  test("command is registered with correct name and options", async () => {
-    const { cmd: statusCmd } = await findCliCommand("status");
-    expect(statusCmd).toBeDefined();
-    expect(statusCmd?.description()).toBe(
-      "Show live status, metrics, and instances of a running simulation",
-    );
-
-    const optionNames = statusCmd?.options.map((o) => o.long);
-    expect(optionNames).toContain("--name");
-    expect(optionNames).toContain("--discover");
-    expect(optionNames).toContain("--watch");
-    expect(optionNames).toContain("--instance");
-    expect(optionNames).toContain("--json");
-    expect(optionNames).toContain("--admin-url");
-    expect(optionNames).toContain("--template");
-  });
-
-  test("--watch has short alias -w", async () => {
-    const { cmd: statusCmd } = await findCliCommand("status");
-    expect(statusCmd).toBeDefined();
-
-    const watchOpt = statusCmd?.options.find((o) => o.long === "--watch");
-    expect(watchOpt).toBeDefined();
-    expect(watchOpt?.short).toBe("-w");
-  });
-
   test("sets exit code 1 with invalid admin URL", async () => {
     const { program } = await findCliCommand("status");
     program.exitOverride();

package/src/commands/templates.test.ts

@@ -41,19 +41,6 @@ describe("formatTemplateInspect", () => {
 });
 
 describe("miravo templates", () => {
-  test("command is registered with list and inspect subcommands", async () => {
-    const { createProgram } = await import("../index.ts");
-    const program = createProgram();
-
-    const templatesCmd = program.commands.find((c) => c.name() === "templates");
-    expect(templatesCmd).toBeDefined();
-    expect(templatesCmd?.description()).toBe("List and inspect Miravo templates");
-
-    const subcommandNames = templatesCmd?.commands.map((c) => c.name()) ?? [];
-    expect(subcommandNames).toContain("list");
-    expect(subcommandNames).toContain("inspect");
-  });
-
   test("templates inspect nonexistent template sets exit code 1", async () => {
     await runCliCommand(["templates", "inspect", "nonexistent-template"]);
     expect(process.exitCode).toBe(1);

package/src/lib/shutdown.ts

@@ -2,7 +2,15 @@ import type { Engine, EngineMetricsSnapshot } from "@miravo/core";
 import type { AdapterHealthSnapshot } from "@miravo/shared";
 import type { TreeItem } from "consola/utils";
 import { box, colors, formatTree, stripAnsi } from "consola/utils";
-import { engineLog, isJsonLogFormat, isPlain, isQuiet, mqttLog, opcuaLog } from "../logger.ts";
+import {
+  engineLog,
+  isJsonLogFormat,
+  isPlain,
+  isQuiet,
+  modbusLog,
+  mqttLog,
+  opcuaLog,
+} from "../logger.ts";
 import { computeAverageThroughput, formatCount, formatDuration } from "../output.ts";
 
 const SHUTDOWN_TASK_TIMEOUT_MS = 6_000;
@@ -261,11 +269,13 @@ function healthStateLabel(state: AdapterHealthSnapshot["state"]): string {
 function adapterLogger(name: string) {
   if (name === "mqtt") return mqttLog;
   if (name === "opcua") return opcuaLog;
+  if (name === "modbus") return modbusLog;
   return engineLog;
 }
 
 function adapterLabel(name: string): string {
   if (name === "opcua") return "OPC UA";
+  if (name === "modbus") return "Modbus";
   return name.toUpperCase();
 }
 
@@ -281,7 +291,7 @@ function formatAdapterLine(
       : colors.yellow(formatCount(m.errorsCount));
   const avgThroughput = computeAverageThroughput(m.messagesPublished, uptimeMs);
   const throughputStr = avgThroughput !== null ? `${sep}${formatCount(avgThroughput)} msg/s` : "";
-  const verb = name === "opcua" ? "updates" : "published";
+  const verb = name === "opcua" || name === "modbus" ? "updates" : "published";
   const health = m.health ? `${sep}${healthStateLabel(m.health.state)}` : "";
   return `${connStr}${sep}${formatCount(m.messagesPublished)} ${verb}${sep}${errStr} errors${throughputStr}${health}`;
 }
@@ -351,7 +361,7 @@ function buildSummaryLines(input: SummaryInput): string[] {
         : colors.yellow(formatCount(m.errorsCount));
     const avgThroughput = computeAverageThroughput(m.messagesPublished, core.uptimeMs);
     const throughputStr = avgThroughput !== null ? `${sep}${formatCount(avgThroughput)} msg/s` : "";
-    const verb = adapter.name === "opcua" ? "updates" : "published";
+    const verb = adapter.name === "opcua" || adapter.name === "modbus" ? "updates" : "published";
     lines.push(
       `${label}: ${connStr}${sep}${colors.bold(formatCount(m.messagesPublished))} ${verb}${sep}${errStr} errors${throughputStr}`,
     );