miravo 0.6.0 → 0.6.2

package/src/commands/start/protocol-plans.ts

@@ -1,239 +0,0 @@
-import type { Engine } from "@miravo/core";
-import type { MiravoTemplate } from "@miravo/shared";
-import { MiravoError } from "@miravo/shared";
-import type { Command } from "commander";
-import { colors } from "consola/utils";
-import { modbusLog, mqttLog, opcuaLog } from "../../logger.ts";
-import {
-  buildModbusDefaultConfig,
-  buildMQTTDefaultConfig,
-  buildOPCUADefaultConfig,
-} from "./adapter-config.ts";
-import type {
-  MqttRunOverrides,
-  ProtocolBootPlan,
-  ProtocolOptionSource,
-  StartOptions,
-} from "./types.ts";
-
-// ---------------------------------------------------------------------------
-// Protocol boot plans
-// ---------------------------------------------------------------------------
-
-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;
-  };
-}
-
-export function getCommandOptionSource(
-  command: Command | undefined,
-  optionName: ProtocolOptionSource,
-): string | undefined {
-  const maybeGetOptionValueSource = (
-    command as Command & { getOptionValueSource?: (key: string) => string | undefined }
-  )?.getOptionValueSource;
-  return maybeGetOptionValueSource?.call(command, optionName);
-}
-
-export function resolveProtocolBootPlans(input: {
-  readonly options: StartOptions & { readonly command?: Command | undefined };
-  readonly optionSources: Partial<Record<ProtocolOptionSource, string | undefined>>;
-  readonly restoredFromPersistence: boolean;
-  readonly persistedDisabledAdapters?: ReadonlySet<string> | undefined;
-  readonly templateProtocols?: MiravoTemplate["protocols"] | undefined;
-}): readonly ProtocolBootPlan[] {
-  const mqttConfigExplicit = [
-    "mqttPort",
-    "mqttHost",
-    "mqttMode",
-    "mqttUrl",
-    "mqttUsername",
-    "mqttPassword",
-  ].some((option) => input.optionSources[option as ProtocolOptionSource] === "cli");
-
-  const opcuaConfigExplicit =
-    input.options.opcua === true &&
-    ["opcuaPort", "opcuaHost"].some(
-      (option) => input.optionSources[option as ProtocolOptionSource] === "cli",
-    );
-
-  const modbusConfigExplicit =
-    input.options.modbus === true &&
-    ["modbusPort", "modbusHost"].some(
-      (option) => input.optionSources[option as ProtocolOptionSource] === "cli",
-    );
-
-  const mqttOverrideRestore =
-    !input.restoredFromPersistence || input.optionSources["mqtt"] === "cli" || mqttConfigExplicit;
-  const opcuaOverrideRestore =
-    !input.restoredFromPersistence || input.optionSources["opcua"] === "cli" || opcuaConfigExplicit;
-  const modbusOverrideRestore =
-    !input.restoredFromPersistence ||
-    input.optionSources["modbus"] === "cli" ||
-    modbusConfigExplicit;
-
-  // When restoring without a CLI override, an adapter explicitly saved as disabled must
-  // stay disabled — the user turned it off and that decision should survive restarts.
-  const persistedDisabled = input.persistedDisabledAdapters ?? new Set<string>();
-
-  return [
-    {
-      name: "mqtt",
-      shouldEnable:
-        input.options.mqtt !== false && (mqttOverrideRestore || !persistedDisabled.has("mqtt")),
-      overrideRestore: mqttOverrideRestore,
-    },
-    {
-      name: "opcua",
-      shouldEnable:
-        (input.options.opcua === true ||
-          (input.options.opcua === undefined && input.templateProtocols?.opcua !== undefined)) &&
-        (opcuaOverrideRestore || !persistedDisabled.has("opcua")),
-      overrideRestore: opcuaOverrideRestore,
-    },
-    {
-      name: "modbus",
-      shouldEnable:
-        (input.options.modbus === true ||
-          (input.options.modbus === undefined && input.templateProtocols?.modbus !== undefined)) &&
-        (modbusOverrideRestore || !persistedDisabled.has("modbus")),
-      overrideRestore: modbusOverrideRestore,
-    },
-  ];
-}
-
-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 ?? 1883) : undefined,
-      host: mqttConfig ? ((mqttConfig as { host?: string }).host ?? "0.0.0.0") : undefined,
-      embedded: mqttConfig ? ((mqttConfig as { embedded?: boolean }).embedded ?? true) : false,
-    },
-    opcua: {
-      port: opcuaConfig ? ((opcuaConfig as { port?: number }).port ?? 4840) : undefined,
-      host: opcuaConfig ? ((opcuaConfig as { host?: string }).host ?? "0.0.0.0") : undefined,
-    },
-    modbus: {
-      port: modbusConfig ? ((modbusConfig as { port?: number }).port ?? 502) : undefined,
-      host: modbusConfig ? ((modbusConfig as { host?: string }).host ?? "0.0.0.0") : undefined,
-    },
-  };
-}
-
-export async function reconcileProtocolBootPlan(
-  engine: Engine,
-  plan: ProtocolBootPlan,
-): Promise<void> {
-  const adapter = engine.getAvailableAdapters().find((candidate) => candidate.name === plan.name);
-  const isEnabled = adapter?.enabled === true;
-
-  if (!plan.shouldEnable) {
-    if (!isEnabled || !plan.overrideRestore) {
-      return;
-    }
-
-    const result = await engine.disableAdapter(plan.name);
-    if (!result.success) {
-      throw new MiravoError(
-        result.message,
-        result.error ?? `Disable adapter "${plan.name}" manually and retry startup.`,
-      );
-    }
-    return;
-  }
-
-  if (plan.overrideRestore && isEnabled) {
-    const disableResult = await engine.disableAdapter(plan.name);
-    if (!disableResult.success) {
-      throw new MiravoError(
-        disableResult.message,
-        disableResult.error ?? `Disable adapter "${plan.name}" manually and retry startup.`,
-      );
-    }
-    if ((disableResult.data as { stopWarning?: boolean } | undefined)?.stopWarning === true) {
-      throw new MiravoError(
-        `Failed to safely reconfigure adapter "${plan.name}" during startup.`,
-        `The previous ${plan.name.toUpperCase()} adapter instance did not stop cleanly. Free the port or clear the persisted adapter state before retrying.`,
-      );
-    }
-  } else if (isEnabled) {
-    return;
-  }
-
-  const result = await engine.enableAdapter(plan.name);
-  if (!result.success) {
-    throw new MiravoError(
-      result.message,
-      result.error ?? `Check ${plan.name.toUpperCase()} configuration.`,
-    );
-  }
-
-  if (plan.name === "mqtt") {
-    mqttLog.ready(
-      `connected · broker: ${colors.cyan(String((result.data as Record<string, unknown>)?.["endpoint"] ?? ""))}`,
-    );
-    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/start/template-loader.ts

@@ -1,197 +0,0 @@
-import { readFileSync } from "node:fs";
-import { basename, resolve } from "node:path";
-import type { ContentCatalog, TwinRuntime } from "@miravo/core";
-import { discoverTemplates } from "@miravo/core";
-import type { CatalogTemplate, MiravoTemplate, TemplateRun } from "@miravo/shared";
-import {
-  MiravoError,
-  MiravoTemplateSchema,
-  TWIN_FILE_EXTENSION,
-  TwinModelSchema,
-} from "@miravo/shared";
-import { parse as parseYAML } from "yaml";
-import { isTemplatePathLike } from "../../lib/template-locator.ts";
-import {
-  buildUNSBasePath,
-  collectReferencedModels,
-  forEachTwin,
-} from "../../lib/template-utils.ts";
-
-// ---------------------------------------------------------------------------
-// Runtime template loader (for loadTemplate command from console/API)
-// ---------------------------------------------------------------------------
-
-interface CachedTemplate {
-  readonly id: string;
-  readonly name: string;
-  readonly path: string;
-}
-
-interface TemplateCacheResult {
-  readonly pathCache: Map<string, CachedTemplate>;
-  readonly catalog: readonly CatalogTemplate[];
-}
-
-/**
- * Discover templates once and build both the path lookup cache (for runtime
- * template loading) and the catalog (for the REST API) in a single pass.
- * All data comes from discovery metadata — no additional file I/O.
- */
-export async function buildTemplateCacheAndCatalog(
-  contentCatalog: ContentCatalog,
-): Promise<TemplateCacheResult> {
-  const pathCache = new Map<string, CachedTemplate>();
-  const catalogEntries: CatalogTemplate[] = [];
-  const discovered = await discoverTemplates(contentCatalog.getBuiltinTemplatesDir());
-
-  for (const t of discovered) {
-    const entry: CachedTemplate = { id: t.id, name: t.name, path: t.path };
-    pathCache.set(t.id, entry);
-    pathCache.set(t.name, entry);
-
-    catalogEntries.push({
-      id: t.id,
-      name: t.name,
-      description: t.description ?? null,
-      category: "Industrial",
-      models: t.modelNames,
-      instanceCount: t.totalTwinCount,
-      memberCount: 0,
-      source: "builtin",
-    });
-  }
-
-  return { pathCache, catalog: catalogEntries };
-}
-
-export function createRuntimeTemplateLoader(
-  catalog: ContentCatalog,
-  templatePathCache: Map<string, CachedTemplate>,
-): (templatePath: string, count: number, runId: number, runtime: TwinRuntime) => TemplateRun {
-  return (templateIdentifier, count, runId, runtime) => {
-    // Resolve template path from pre-built cache or as a file path
-    let templatePath: string;
-    let slugName: string;
-    if (isTemplatePathLike(templateIdentifier)) {
-      templatePath = resolve(templateIdentifier);
-      slugName = basename(templatePath).replace(/\.miravo\.yaml$/, "");
-    } else {
-      const cached = templatePathCache.get(templateIdentifier);
-      if (!cached) {
-        const ids = [...new Set([...templatePathCache.values()].map((e) => e.id))];
-        throw new MiravoError(
-          `Template "${templateIdentifier}" not found.`,
-          `Available templates: ${ids.join(", ") || "(none)"}`,
-        );
-      }
-      templatePath = cached.path;
-      slugName = cached.id;
-    }
-
-    const template = loadTemplateSync(templatePath);
-    const referencedModels = registerTemplateModels(catalog, templatePath, template, runtime);
-
-    // Spawn instances with auto-prefix using kebab-case slug
-    const prefix = `${slugName}-${runId}`;
-    const allInstanceIds: string[] = [];
-
-    for (let c = 0; c < count; c++) {
-      const runPrefix = count > 1 ? `${prefix}-${c + 1}` : prefix;
-      forEachTwin(template, (area, line, twin) => {
-        const unsBasePath = `${runPrefix}/${buildUNSBasePath(template, area.name, line.name)}`;
-        const spawned = runtime.spawn(twin.model, twin.count, {
-          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) {
-          allInstanceIds.push(node.id);
-        }
-      });
-    }
-
-    return {
-      templateRunId: runId,
-      templateName: template.name,
-      templatePath,
-      prefix,
-      instanceIds: allInstanceIds,
-      models: [...referencedModels],
-    };
-  };
-}
-
-function loadTemplateSync(templatePath: string): MiravoTemplate {
-  try {
-    return MiravoTemplateSchema.parse(parseYAML(readFileSync(templatePath, "utf-8")));
-  } catch (err) {
-    throw new MiravoError(
-      `Failed to load template "${templatePath}".`,
-      err instanceof Error ? err.message : "Check that the file is valid YAML.",
-    );
-  }
-}
-
-export function registerModelFromSearchPaths(
-  runtime: TwinRuntime,
-  modelName: string,
-  searchPaths: readonly string[],
-): void {
-  if (runtime.getModel(modelName)) {
-    return;
-  }
-
-  const { path: modelPath, content: modelContent } = loadModelSync(modelName, searchPaths);
-  try {
-    const model = TwinModelSchema.parse(parseYAML(modelContent));
-    runtime.registerModel(model);
-  } catch (err) {
-    throw new MiravoError(
-      `Failed to load model "${modelName}" from "${modelPath}".`,
-      err instanceof Error ? err.message : "Check that the model file is valid YAML.",
-    );
-  }
-}
-
-export function loadTemplateModels(
-  catalog: ContentCatalog,
-  templatePath: string,
-  runtime: TwinRuntime,
-): readonly string[] {
-  const template = loadTemplateSync(templatePath);
-  return registerTemplateModels(catalog, templatePath, template, runtime);
-}
-
-function registerTemplateModels(
-  catalog: ContentCatalog,
-  templatePath: string,
-  template: MiravoTemplate,
-  runtime: TwinRuntime,
-): readonly string[] {
-  const referencedModels = collectReferencedModels(template);
-  const searchPaths = catalog.getTemplateValidationSearchPaths(templatePath);
-  for (const modelName of referencedModels) {
-    registerModelFromSearchPaths(runtime, modelName, searchPaths);
-  }
-  return [...referencedModels];
-}
-
-function loadModelSync(
-  modelName: string,
-  searchPaths: readonly string[],
-): { path: string; content: string } {
-  for (const dir of searchPaths) {
-    const candidate = resolve(dir, `${modelName}${TWIN_FILE_EXTENSION}`);
-    try {
-      return { path: candidate, content: readFileSync(candidate, "utf-8") };
-    } catch {
-      // File doesn't exist or can't be read — try next path
-    }
-  }
-  throw new MiravoError(
-    `Model "${modelName}" not found in search paths.`,
-    `Searched: ${searchPaths.join(", ")}. Ensure the model file exists as "${modelName}${TWIN_FILE_EXTENSION}".`,
-  );
-}

package/src/commands/start/template-resolver.ts

@@ -1,185 +0,0 @@
-import { basename } from "node:path";
-import type { Option as ClackOption } from "@clack/prompts";
-import { isCancel, select } from "@clack/prompts";
-import type { ContentCatalog } from "@miravo/core";
-import { discoverTemplates, resolveMiravoHome } from "@miravo/core";
-import type { DiscoveredTemplate } from "@miravo/shared";
-import { ConfigNotFoundError, MiravoError, PersistedStateSchema } from "@miravo/shared";
-import { Glob } from "bun";
-import {
-  groupTemplatesByCategory,
-  isStressBenchmarkTemplate,
-  sortTemplatesByCategoryAndName,
-} from "../../lib/template-category.ts";
-import {
-  discoverPreferredLocalTemplates,
-  resolveTemplateIdentifier,
-} from "../../lib/template-locator.ts";
-import { configLog } from "../../logger.ts";
-
-// ---------------------------------------------------------------------------
-// Step 1: Template resolution
-// ---------------------------------------------------------------------------
-
-export 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;
-  }
-}
-
-export 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;
-}
-
-export async function resolveTemplatePath(
-  templateOption: string | undefined,
-  catalog: ContentCatalog,
-): Promise<string> {
-  // 1. Explicit --template identifier or path
-  if (templateOption) {
-    return resolveTemplateIdentifier(templateOption, catalog);
-  }
-
-  // 2. Auto-discover local templates from content dir (if configured) and CWD
-  const discovered = await discoverPreferredLocalTemplates(catalog);
-  if (discovered.length === 1) {
-    const first = discovered[0];
-    if (first !== undefined) {
-      configLog.debug(`Found template: ${first.name} (${first.path})`);
-      return first.path;
-    }
-  }
-  if (discovered.length > 1) {
-    if (!process.stdout.isTTY || !process.stdin.isTTY) {
-      const names = discovered.map((t) => t.name).join(", ");
-      throw new MiravoError(
-        `Found ${discovered.length} templates: ${names}.`,
-        "Use '--template <name|path>' to specify which template to use.",
-      );
-    }
-    const first = discovered[0];
-    if (first !== undefined) {
-      configLog.warn(
-        `Found ${discovered.length} templates: ${discovered.map((t) => t.name).join(", ")}. Using ${first.name}. Use '--template <name|path>' to specify.`,
-      );
-      return first.path;
-    }
-  }
-
-  // 3. Fall back to built-in templates
-  const builtinTemplateDir = catalog.getBuiltinTemplatesDir();
-  let builtinTemplates: readonly DiscoveredTemplate[] = [];
-  try {
-    const discovered = await discoverTemplates(builtinTemplateDir);
-    // Exclude stress/benchmark templates from built-in list (same as standalone binaries).
-    builtinTemplates = discovered.filter((t) => !isStressBenchmarkTemplate(t.id));
-  } catch {
-    // Builtin dir may not exist in edge cases (e.g. standalone binary extraction failure)
-  }
-  if (builtinTemplates.length > 0) {
-    if (process.stdout.isTTY && process.stdin.isTTY) {
-      return pickBuiltinTemplate(builtinTemplates);
-    }
-    const selected = selectDefaultBuiltinTemplate(builtinTemplates);
-    if (selected !== undefined) {
-      configLog.debug(`No template specified. Using built-in "${selected.name}".`);
-      configLog.debug(
-        "Run 'miravo templates list' to see all options, or use --template <name|path>.",
-      );
-      return selected.path;
-    }
-  }
-
-  // 4. Nothing available
-  throw new ConfigNotFoundError(
-    "No template found. Use 'miravo templates list' to find built-ins or pass 'miravo start --template <name|path>'.",
-  );
-}
-
-async function pickBuiltinTemplate(templates: readonly DiscoveredTemplate[]): Promise<string> {
-  configLog.info("No template found in current directory.\n");
-
-  const choice = await select({
-    message: "Choose a built-in template to get started:",
-    options: buildBuiltinTemplateChoices(templates),
-    maxItems: 9,
-  });
-
-  if (isCancel(choice)) {
-    process.exit(0);
-  }
-
-  configLog.info("Tip: use --template <id> to skip this prompt next time.");
-
-  return choice as string;
-}
-
-export function buildBuiltinTemplateChoices(
-  templates: readonly DiscoveredTemplate[],
-): Array<ClackOption<string>> {
-  const groupedTemplates = groupTemplatesByCategory(sortTemplatesByCategoryAndName(templates));
-  const choices: ClackOption<string>[] = [];
-
-  for (const group of groupedTemplates) {
-    choices.push({
-      value: `__header__${group.category}`,
-      label: group.category,
-      hint: `${group.templates.length} templates`,
-      disabled: true,
-    });
-
-    for (const [index, template] of group.templates.entries()) {
-      const isLast = index === group.templates.length - 1;
-      const branch = isLast ? "\u2514\u2500" : "\u251C\u2500";
-      const label = `  ${branch} ${template.name}`;
-      const hintPrefix = template.description ?? template.id;
-      choices.push({
-        value: template.path,
-        label,
-        hint: `${hintPrefix} \u00B7 ${template.uniqueModelCount} models \u00B7 ${template.totalTwinCount} twins`,
-      });
-    }
-  }
-
-  return choices;
-}
-
-function selectDefaultBuiltinTemplate(
-  templates: readonly DiscoveredTemplate[],
-): DiscoveredTemplate | undefined {
-  const preferredFilename = "smart-factory.miravo.yaml";
-  return (
-    templates.find((template) => basename(template.path) === preferredFilename) ?? templates[0]
-  );
-}

package/src/commands/start/types.ts

@@ -1,73 +0,0 @@
-import type { Command } from "commander";
-
-export interface StartOptions {
-  readonly name?: string;
-  readonly template?: string;
-  readonly modelsDir?: string;
-  readonly speed?: number;
-  readonly seed?: number;
-  readonly tick?: number;
-  readonly mqttPort?: number;
-  readonly mqttHost?: string;
-  readonly mqttMode?: string;
-  readonly mqttUrl?: string;
-  readonly mqttUsername?: string;
-  readonly mqttPassword?: string;
-  readonly mqtt?: boolean;
-  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;
-  readonly summaryInterval?: number;
-  readonly ui?: boolean;
-  readonly auth?: boolean;
-  readonly resetState?: boolean;
-  readonly detach?: boolean;
-  readonly command?: Command;
-}
-
-export interface RestoreSummary {
-  readonly instanceCount: number;
-  readonly templateRunCount: number;
-  readonly adapterCount: number;
-  readonly stateFilePath: string;
-}
-
-export interface ProtocolBootPlan {
-  readonly name: "mqtt" | "opcua" | "modbus";
-  readonly shouldEnable: boolean;
-  readonly overrideRestore: boolean;
-}
-
-export type ProtocolOptionSource =
-  | "mqtt"
-  | "opcua"
-  | "modbus"
-  | "mqttPort"
-  | "mqttHost"
-  | "mqttMode"
-  | "mqttUrl"
-  | "mqttUsername"
-  | "mqttPassword"
-  | "opcuaPort"
-  | "opcuaHost"
-  | "modbusPort"
-  | "modbusHost";
-
-export type MqttMode = "embedded" | "external";
-
-export interface MqttRunOverrides {
-  readonly mode?: MqttMode;
-  readonly host?: string;
-  readonly url?: string;
-  readonly username?: string;
-  readonly password?: string;
-  readonly drainBudget?: number;
-  readonly batchSize?: number;
-  readonly brokerConcurrency?: number;
-}