miravo 0.4.0 → 0.5.0

package/console-dist/index.html

@@ -5,7 +5,7 @@
     <link rel="icon" type="image/svg+xml" href="/favicon.svg" />
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
     <title>Miravo</title>
-    <script type="module" crossorigin src="/assets/index-hUJSpKtB.js"></script>
+    <script type="module" crossorigin src="/assets/index-C1oOHU1J.js"></script>
     <link rel="stylesheet" crossorigin href="/assets/index-C3XMYq26.css">
   </head>
   <body>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "miravo",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "type": "module",
   "description": "Industrial environment platform with canonical asset models and MQTT + OPC UA protocol adapters",
   "license": "Apache-2.0",
@@ -32,10 +32,11 @@
   ],
   "dependencies": {
     "@clack/prompts": "^1.1.0",
-    "@miravo/core": "0.4.0",
-    "@miravo/mqtt": "0.4.0",
-    "@miravo/opcua": "0.4.0",
-    "@miravo/shared": "0.4.0",
+    "@miravo/core": "0.5.0",
+    "@miravo/mqtt": "0.5.0",
+    "@miravo/opcua": "0.5.0",
+    "@miravo/modbus": "0.5.0",
+    "@miravo/shared": "0.5.0",
     "commander": "^13.0.0",
     "consola": "^3.4.0",
     "mqtt": "^5.15.0",

package/src/commands/start.test.ts

@@ -221,6 +221,7 @@ describe("resolveProtocolBootPlans", () => {
     ).toEqual([
       { name: "mqtt", shouldEnable: true, overrideRestore: false },
       { name: "opcua", shouldEnable: false, overrideRestore: false },
+      { name: "modbus", shouldEnable: false, overrideRestore: false },
     ]);
   });
 
@@ -236,6 +237,7 @@ describe("resolveProtocolBootPlans", () => {
     ).toEqual([
       { name: "mqtt", shouldEnable: true, overrideRestore: true },
       { name: "opcua", shouldEnable: false, overrideRestore: true },
+      { name: "modbus", shouldEnable: false, overrideRestore: true },
     ]);
   });
 
@@ -300,6 +302,126 @@ describe("resolveProtocolBootPlans", () => {
   });
 });
 
+describe("resolveDetachAdapterConfigs", () => {
+  test("uses template adapter configs when no CLI/env overrides are provided", async () => {
+    const { resolveDetachAdapterConfigs } = await import("./start.ts");
+
+    const template = createTemplateWithNamespace({ prefix: "factory" });
+    const withProtocols: MiravoTemplate = {
+      ...template,
+      protocols: {
+        mqtt: { port: 1889, embedded: true, retain: false, metadata: "base" },
+        opcua: { port: 4851, host: "127.0.0.1", security: "none" },
+        modbus: { port: 1602, host: "127.0.0.1" },
+      },
+    };
+
+    expect(
+      resolveDetachAdapterConfigs({
+        template: withProtocols,
+        simulationName: "factory-sim",
+        mqtt: { enabled: true, portOverride: undefined, overrides: {} },
+        opcua: {
+          enabled: true,
+          portOverride: undefined,
+          hostOverride: undefined,
+          writeBudgetOverride: undefined,
+        },
+        modbus: { enabled: true, portOverride: undefined, hostOverride: undefined },
+      }),
+    ).toEqual({
+      mqtt: { port: 1889, host: "127.0.0.1", embedded: true },
+      opcua: { port: 4851, host: "127.0.0.1" },
+      modbus: { port: 1602, host: "127.0.0.1" },
+    });
+  });
+
+  test("CLI/env overrides take precedence over template values", async () => {
+    const { resolveDetachAdapterConfigs } = await import("./start.ts");
+
+    const template = createTemplateWithNamespace({ prefix: "factory" });
+    const withProtocols: MiravoTemplate = {
+      ...template,
+      protocols: {
+        mqtt: { port: 1889, embedded: true, retain: false, metadata: "base" },
+        opcua: { port: 4851, host: "127.0.0.1", security: "none" },
+        modbus: { port: 1602, host: "127.0.0.1" },
+      },
+    };
+
+    expect(
+      resolveDetachAdapterConfigs({
+        template: withProtocols,
+        simulationName: "factory-sim",
+        mqtt: {
+          enabled: true,
+          portOverride: 1999,
+          overrides: { host: "0.0.0.0" },
+        },
+        opcua: {
+          enabled: true,
+          portOverride: 4852,
+          hostOverride: "0.0.0.0",
+          writeBudgetOverride: undefined,
+        },
+        modbus: { enabled: true, portOverride: 1702, hostOverride: "0.0.0.0" },
+      }),
+    ).toEqual({
+      mqtt: { port: 1999, host: "0.0.0.0", embedded: true },
+      opcua: { port: 4852, host: "0.0.0.0" },
+      modbus: { port: 1702, host: "0.0.0.0" },
+    });
+  });
+
+  test("returns disabled placeholders when adapters are disabled", async () => {
+    const { resolveDetachAdapterConfigs } = await import("./start.ts");
+    const template = createTemplateWithNamespace({ prefix: "factory" });
+
+    expect(
+      resolveDetachAdapterConfigs({
+        template,
+        simulationName: "factory-sim",
+        mqtt: { enabled: false, portOverride: 1999, overrides: { host: "0.0.0.0" } },
+        opcua: {
+          enabled: false,
+          portOverride: 4852,
+          hostOverride: "0.0.0.0",
+          writeBudgetOverride: 4096,
+        },
+        modbus: { enabled: false, portOverride: 1702, hostOverride: "0.0.0.0" },
+      }),
+    ).toEqual({
+      mqtt: { port: undefined, host: undefined, embedded: false },
+      opcua: { port: undefined, host: undefined },
+      modbus: { port: undefined, host: undefined },
+    });
+  });
+
+  test("marks external MQTT mode as non-embedded for detach conflict checks", async () => {
+    const { resolveDetachAdapterConfigs } = await import("./start.ts");
+    const template = createTemplateWithNamespace({ prefix: "factory" });
+
+    expect(
+      resolveDetachAdapterConfigs({
+        template,
+        simulationName: "factory-sim",
+        mqtt: {
+          enabled: true,
+          portOverride: undefined,
+          overrides: { mode: "external", url: "mqtt://broker.example.com:1883" },
+        },
+        opcua: {
+          enabled: false,
+          portOverride: undefined,
+          hostOverride: undefined,
+          writeBudgetOverride: undefined,
+        },
+        modbus: { enabled: false, portOverride: undefined, hostOverride: undefined },
+      }).mqtt.embedded,
+    ).toBe(false);
+  });
+});
+
 describe("error context aggregation", () => {
   test("normalizeErrorContext redacts high-cardinality fragments", async () => {
     const { normalizeErrorContext } = await import("./start.ts");

package/src/commands/start.ts

@@ -13,6 +13,7 @@ import {
   resolveModelPath,
   validateFullTemplate,
 } from "@miravo/core";
+import { ModbusAdapter } from "@miravo/modbus";
 import { MQTTAdapter } from "@miravo/mqtt";
 import { OPCUAAdapter } from "@miravo/opcua";
 import type {
@@ -25,6 +26,7 @@ import type {
 import {
   ConfigNotFoundError,
   ConfigValidationError,
+  DEFAULT_MODBUS_PORT,
   DEFAULT_MQTT_PORT,
   DEFAULT_OPCUA_PORT,
   DEFAULT_TICK_INTERVAL_MS,
@@ -80,6 +82,7 @@ import {
   handleCommandError,
   isPlain,
   lifecycleLog,
+  modbusLog,
   mqttLog,
   opcuaLog,
   setRuntimeLogContext,
@@ -104,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;
@@ -121,7 +127,7 @@ interface RestoreSummary {
 }
 
 interface ProtocolBootPlan {
-  readonly name: "mqtt" | "opcua";
+  readonly name: "mqtt" | "opcua" | "modbus";
   readonly shouldEnable: boolean;
   readonly overrideRestore: boolean;
 }
@@ -129,6 +135,7 @@ interface ProtocolBootPlan {
 type ProtocolOptionSource =
   | "mqtt"
   | "opcua"
+  | "modbus"
   | "mqttPort"
   | "mqttHost"
   | "mqttMode"
@@ -136,7 +143,9 @@ type ProtocolOptionSource =
   | "mqttUsername"
   | "mqttPassword"
   | "opcuaPort"
-  | "opcuaHost";
+  | "opcuaHost"
+  | "modbusPort"
+  | "modbusHost";
 
 type MqttMode = "embedded" | "external";
 
@@ -161,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;
@@ -218,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>",
@@ -277,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) {
@@ -302,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"];
@@ -392,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 {
@@ -457,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,
@@ -464,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;
     }
@@ -590,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)
@@ -694,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,
@@ -701,6 +797,7 @@ async function startAction(options: StartOptions): Promise<void> {
       seedExplicit,
       mqttEndpoint,
       opcuaEndpoint,
+      modbusEndpoint,
       simulationName,
       runId,
       adminServer.endpoint,
@@ -754,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> {
@@ -791,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) {
@@ -852,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,
@@ -955,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}`);
     }
@@ -1283,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,
       });
@@ -1633,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
 // ---------------------------------------------------------------------------
@@ -1644,6 +1788,7 @@ function printStartupBanner(
   seedExplicit: boolean,
   mqttEndpoint: string | null,
   opcuaEndpoint: string | null,
+  modbusEndpoint: string | null,
   simulationName: string,
   runId: string,
   adminEndpoint: string,
@@ -1662,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)],
@@ -1671,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`)],
@@ -1849,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",
@@ -1866,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;
@@ -1921,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/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}`,
     );