miravo 0.6.0 → 0.6.2

package/src/__tests__/integration/opcua-concurrent-clients.integration.ts

@@ -1,314 +0,0 @@
-/**
- * E2E test: concurrent OPC UA client connections, reads, clean + unclean disconnect,
- * and reconnect. Validates the session-pool hardening changes (MAX_SESSIONS, HELLO_TIMEOUT).
- */
-import { describe, expect, test } from "bun:test";
-import type { EventEmitter } from "node:events";
-import { mkdir, mkdtemp, rm } from "node:fs/promises";
-import { createServer } from "node:net";
-import { tmpdir } from "node:os";
-import { join, resolve } from "node:path";
-import type { ClientSession } from "node-opcua-client";
-import { AttributeIds, MessageSecurityMode, OPCUAClient, SecurityPolicy } from "node-opcua-client";
-import { stringify as stringifyYAML } from "yaml";
-
-async function canBindLocalTcp(): Promise<boolean> {
-  const probe = createServer();
-  return new Promise((res) => {
-    const cleanup = () => {
-      try {
-        probe.close();
-      } catch {
-        /* ignore */
-      }
-    };
-    (probe as unknown as EventEmitter).once("error", () => {
-      cleanup();
-      res(false);
-    });
-    (probe as unknown as EventEmitter).once("listening", () => {
-      cleanup();
-      res(true);
-    });
-    probe.listen(0, "127.0.0.1");
-  });
-}
-
-const TCP_AVAILABLE = await canBindLocalTcp();
-const describeIfTcp = TCP_AVAILABLE ? describe : describe.skip;
-
-interface RuntimeHandle {
-  readonly process: Bun.Subprocess<"ignore", "pipe", "pipe">;
-  readonly tmpDir: string;
-  readonly opcuaPort: number;
-  readonly instancePath: string;
-}
-
-async function startRuntime(): Promise<RuntimeHandle> {
-  const tmpDir = await mkdtemp(join(tmpdir(), "miravo-opcua-e2e-"));
-  const modelsDir = join(tmpDir, "models");
-  const templatePath = join(tmpDir, "e2e.miravo.yaml");
-  const modelPath = join(modelsDir, "e2e-pump.twin.yaml");
-  const readyFile = join(tmpDir, "ready.json");
-
-  await mkdir(modelsDir, { recursive: true });
-
-  await Bun.write(
-    modelPath,
-    stringifyYAML({
-      schema_version: "2",
-      model: {
-        name: "e2e-pump",
-        namespace: "com.miravo.testing.e2e-pump",
-        description: "Minimal pump for OPC UA concurrent-client e2e test.",
-      },
-      parameters: {},
-      methods: {},
-      members: {
-        speed: {
-          kind: "variable",
-          data_type: "Double",
-          access: "read",
-          unit: "rpm",
-          generator: { type: "sine", center: 500, amplitude: 100, period: 10 },
-        },
-        status: {
-          kind: "property",
-          data_type: "String",
-          access: "read",
-          default: "running",
-        },
-      },
-      faults: [],
-    }),
-  );
-
-  await Bun.write(
-    templatePath,
-    stringifyYAML({
-      kind: "MiravoTemplate",
-      version: "1",
-      name: "E2E Template",
-      namespace: { prefix: "e2e" },
-      areas: [
-        {
-          name: "plant",
-          lines: [{ name: "line1", twins: [{ model: "e2e-pump", count: 1, variation: 0 }] }],
-        },
-      ],
-      settings: { seed: 1, tick_interval_ms: 100, time_multiplier: 1 },
-    }),
-  );
-
-  const proc = Bun.spawn({
-    cmd: [
-      "bun",
-      "run",
-      resolve(import.meta.dir, "executable-methods-runner.ts"),
-      "--template",
-      templatePath,
-      "--models-dir",
-      modelsDir,
-      "--ready-file",
-      readyFile,
-    ],
-    cwd: resolve("."),
-    stdin: "ignore",
-    stdout: "pipe",
-    stderr: "pipe",
-  });
-
-  try {
-    const ready = await Promise.race([
-      (async () => {
-        const deadline = Date.now() + 20_000;
-        while (Date.now() < deadline) {
-          if (!(await Bun.file(readyFile).exists())) {
-            await Bun.sleep(50);
-            continue;
-          }
-          return (await Bun.file(readyFile).json()) as {
-            readonly opcuaEndpointUrl: string;
-            readonly instancePath: string;
-          };
-        }
-        throw new Error("Runtime did not write ready file within 20 s");
-      })(),
-      proc.exited.then((code) => {
-        throw new Error(`Runtime exited early with code ${code}`);
-      }),
-    ]);
-
-    const match = ready.opcuaEndpointUrl.match(/:(\d+)\//);
-    const opcuaPort = match?.[1] ? Number.parseInt(match[1], 10) : 0;
-    return { process: proc, tmpDir, opcuaPort, instancePath: ready.instancePath };
-  } catch (error) {
-    proc.kill("SIGTERM");
-    await proc.exited;
-    const stdout = proc.stdout ? await new Response(proc.stdout).text() : "";
-    const stderr = proc.stderr ? await new Response(proc.stderr).text() : "";
-    await rm(tmpDir, { recursive: true, force: true });
-    throw new Error(
-      [
-        `Failed to start runtime: ${error instanceof Error ? error.message : String(error)}`,
-        stdout.trim() ? `stdout:\n${stdout.trim()}` : "",
-        stderr.trim() ? `stderr:\n${stderr.trim()}` : "",
-      ]
-        .filter(Boolean)
-        .join("\n\n"),
-    );
-  }
-}
-
-async function stopRuntime(handle: RuntimeHandle): Promise<void> {
-  handle.process.kill("SIGTERM");
-  await Promise.race([
-    handle.process.exited,
-    Bun.sleep(8_000).then(() => handle.process.kill("SIGKILL")),
-  ]);
-  await rm(handle.tmpDir, { recursive: true, force: true });
-}
-
-function makeClient(): OPCUAClient {
-  return OPCUAClient.create({
-    securityMode: MessageSecurityMode.None,
-    securityPolicy: SecurityPolicy.None,
-    endpointMustExist: false,
-    connectionStrategy: { maxRetry: 0, initialDelay: 0 },
-  });
-}
-
-/**
- * Creates a client that will NOT send CloseSession on disconnect.
- * `keepPendingSessionsOnDisconnect: true` skips `_close_pending_sessions()`,
- * so the server retains the session slot until its 30 s watchdog fires.
- * Use this to simulate unclean client crashes.
- */
-function makeZombieClient(): OPCUAClient {
-  return OPCUAClient.create({
-    securityMode: MessageSecurityMode.None,
-    securityPolicy: SecurityPolicy.None,
-    endpointMustExist: false,
-    connectionStrategy: { maxRetry: 0, initialDelay: 0 },
-    keepPendingSessionsOnDisconnect: true,
-  });
-}
-
-async function connectClient(
-  port: number,
-): Promise<{ client: OPCUAClient; session: ClientSession }> {
-  const client = makeClient();
-  await client.connect(`opc.tcp://127.0.0.1:${port}`);
-  const session = await client.createSession();
-  return { client, session };
-}
-
-async function closeClient(client: OPCUAClient, session: ClientSession): Promise<void> {
-  await session.close().catch(() => {});
-  await client.disconnect().catch(() => {});
-}
-
-async function readSpeed(session: ClientSession, instancePath: string): Promise<number> {
-  const dv = await session.read({
-    nodeId: `ns=1;s=${instancePath}/speed`,
-    attributeId: AttributeIds.Value,
-  });
-  const v = dv.value.value;
-  if (typeof v !== "number") throw new Error(`Expected number, got ${typeof v}`);
-  return v;
-}
-
-describeIfTcp("OPC UA concurrent-client e2e", () => {
-  let runtime: RuntimeHandle | undefined;
-
-  test("setup: start miravo runtime with OPC UA", async () => {
-    runtime = await startRuntime();
-    expect(runtime.opcuaPort).toBeGreaterThan(0);
-  }, 30_000);
-
-  test("20 clients connect concurrently and all read a value", async () => {
-    if (!runtime) return;
-    const rt = runtime;
-    const N = 20;
-    const handles = await Promise.all(Array.from({ length: N }, () => connectClient(rt.opcuaPort)));
-    try {
-      const values = await Promise.all(
-        handles.map(({ session }) => readSpeed(session, rt.instancePath)),
-      );
-      expect(values).toHaveLength(N);
-      for (const v of values) {
-        expect(typeof v).toBe("number");
-        expect(Number.isFinite(v)).toBe(true);
-      }
-      console.log(`  ✓  ${N} concurrent clients read speed; sample: ${values[0]?.toFixed(2)}`);
-    } finally {
-      await Promise.all(handles.map(({ client, session }) => closeClient(client, session)));
-    }
-  }, 30_000);
-
-  test("client disconnects cleanly and reconnects — reads succeed after reconnect", async () => {
-    if (!runtime) return;
-    const { client: c1, session: s1 } = await connectClient(runtime.opcuaPort);
-    const before = await readSpeed(s1, runtime.instancePath);
-    await closeClient(c1, s1);
-    console.log(`  ✓  Client read ${before.toFixed(2)} before clean disconnect`);
-
-    const { client: c2, session: s2 } = await connectClient(runtime.opcuaPort);
-    try {
-      const after = await readSpeed(s2, runtime.instancePath);
-      expect(typeof after).toBe("number");
-      console.log(`  ✓  Reconnected client read ${after.toFixed(2)}`);
-    } finally {
-      await closeClient(c2, s2);
-    }
-  }, 20_000);
-
-  test("unclean disconnect stress: 15 zombie sessions exhaust old default (10) — new client still connects", async () => {
-    if (!runtime) return;
-    const rt = runtime;
-    // node-opcua default maxSessions is 10; our fix sets it to 500.
-    // makeZombieClient() uses keepPendingSessionsOnDisconnect:true so client.disconnect()
-    // skips CloseSession — the server retains each session slot for ~30 s (session watchdog).
-    // With the old default, the 11th slot is unavailable → connectClient() throws
-    // BadTooManySessions → test fails.
-    const ZOMBIE_COUNT = 15; // intentionally > old default of 10
-
-    const zombies = await Promise.all(
-      Array.from({ length: ZOMBIE_COUNT }, async () => {
-        const client = makeZombieClient();
-        await client.connect(`opc.tcp://127.0.0.1:${rt.opcuaPort}`);
-        const session = await client.createSession();
-        return { client, session };
-      }),
-    );
-    // Disconnect without CloseSession — server retains sessions, consuming pool slots.
-    await Promise.all(zombies.map(({ client }) => client.disconnect().catch(() => {})));
-    console.log(`  ✓  ${ZOMBIE_COUNT} zombie sessions dropped (linger on server for ~30 s)`);
-
-    const { client: fresh, session: freshSession } = await connectClient(runtime.opcuaPort);
-    try {
-      const v = await readSpeed(freshSession, runtime.instancePath);
-      expect(typeof v).toBe("number");
-      console.log(
-        `  ✓  Client #${ZOMBIE_COUNT + 1} connected and read ${v.toFixed(2)} while ${ZOMBIE_COUNT} zombie sessions hold server slots`,
-      );
-    } finally {
-      await closeClient(fresh, freshSession);
-    }
-  }, 30_000);
-
-  test("10 sequential connect/read/disconnect cycles complete without error", async () => {
-    if (!runtime) return;
-    for (let i = 0; i < 10; i++) {
-      const { client, session } = await connectClient(runtime.opcuaPort);
-      const v = await readSpeed(session, runtime.instancePath);
-      expect(typeof v).toBe("number");
-      await closeClient(client, session);
-    }
-    console.log("  ✓  10 sequential connect-read-disconnect cycles completed");
-  }, 30_000);
-
-  test("teardown: stop miravo runtime", async () => {
-    if (runtime) await stopRuntime(runtime);
-  }, 15_000);
-});

package/src/commands/adapter.ts

@@ -1,249 +0,0 @@
-import type { EngineCommand } from "@miravo/shared";
-import { CONTROL_CMD_TIMEOUT_MS } from "@miravo/shared";
-import type { Command } from "commander";
-import { colors } from "consola/utils";
-import { executeAdminCommand, getManifest, resolveAdminUrl } from "../lib/admin-client.ts";
-import { parsePositiveInt, parseTimeoutSeconds } from "../lib/parse.ts";
-import {
-  engineLog,
-  handleCommandError,
-  handleCommandResult,
-  modbusLog,
-  writeOutput,
-} from "../logger.ts";
-import { formatTable } from "../output.ts";
-
-interface AdapterOptions {
-  readonly port?: number;
-  readonly host?: string;
-  readonly json?: boolean;
-  readonly adminUrl?: string;
-  readonly timeout?: number;
-}
-
-export function registerAdapterCommand(program: Command): void {
-  const adapter = program
-    .command("adapter")
-    .description("Manage protocol adapters (MQTT, OPC UA, Modbus)");
-
-  adapter
-    .command("enable <name>")
-    .description("Enable a protocol adapter (mqtt, opcua, modbus)")
-    .option("-p, --port <number>", "Override adapter port", parsePositiveInt)
-    .option("--host <host>", "Override adapter bind host")
-    .option("--json", "Machine-readable JSON output")
-    .option("--admin-url <url>", "Admin API URL (env: MIRAVO_ADMIN_URL)")
-    .option("--timeout <seconds>", "Timeout in seconds (default: 5)", parseTimeoutSeconds)
-    .addHelpText(
-      "after",
-      `
-Examples:
-  $ miravo adapter enable mqtt             Enable MQTT adapter
-  $ miravo adapter enable opcua -p 4841    Enable OPC UA on custom port`,
-    )
-    .action(async (name: string, options: AdapterOptions) => {
-      try {
-        const adminUrl = resolveAdminUrl(options.adminUrl);
-        const timeoutMs = options.timeout ?? CONTROL_CMD_TIMEOUT_MS;
-        const config: Record<string, unknown> = {};
-        if (options.port !== undefined) config["port"] = options.port;
-        if (options.host !== undefined) config["host"] = options.host;
-        const command: EngineCommand = {
-          type: "enableAdapter",
-          adapter: name,
-          ...(Object.keys(config).length > 0 ? { config } : {}),
-        };
-        const result = await executeAdminCommand(adminUrl, command, timeoutMs);
-        handleCommandResult(result, options.json);
-      } catch (error) {
-        handleCommandError(error);
-      }
-    });
-
-  adapter
-    .command("disable <name>")
-    .description("Disable a running protocol adapter (mqtt, opcua, modbus)")
-    .option("--json", "Machine-readable JSON output")
-    .option("--admin-url <url>", "Admin API URL (env: MIRAVO_ADMIN_URL)")
-    .option("--timeout <seconds>", "Timeout in seconds (default: 5)", parseTimeoutSeconds)
-    .addHelpText(
-      "after",
-      `
-Examples:
-  $ miravo adapter disable mqtt            Disable MQTT adapter`,
-    )
-    .action(async (name: string, options: AdapterOptions) => {
-      try {
-        const adminUrl = resolveAdminUrl(options.adminUrl);
-        const timeoutMs = options.timeout ?? CONTROL_CMD_TIMEOUT_MS;
-        const command: EngineCommand = { type: "disableAdapter", adapter: name };
-        const result = await executeAdminCommand(adminUrl, command, timeoutMs);
-        handleCommandResult(result, options.json);
-      } catch (error) {
-        handleCommandError(error);
-      }
-    });
-
-  // Generic adapter introspection via unified manifest
-  const inspectAction = async (name: string | undefined, options: AdapterOptions) => {
-    try {
-      const adapterName = name ?? "modbus";
-      const adminUrl = resolveAdminUrl(options.adminUrl);
-      const timeoutMs = options.timeout ?? CONTROL_CMD_TIMEOUT_MS;
-      const manifest = await getManifest(adminUrl, timeoutMs);
-
-      const allTags = manifest["tags"] as Array<Record<string, unknown>> | undefined;
-      if (!allTags || allTags.length === 0) {
-        engineLog.warn("No tags found.");
-        return;
-      }
-
-      // Filter to tags that have data for the requested protocol
-      const tags = allTags.filter((s) => {
-        const protocols = s["protocols"] as Record<string, unknown> | undefined;
-        return protocols?.[adapterName] !== undefined;
-      });
-
-      if (tags.length === 0) {
-        engineLog.warn(`No tags found for ${adapterName} adapter.`);
-        return;
-      }
-
-      if (options.json) {
-        writeOutput(JSON.stringify(tags, null, 2));
-        return;
-      }
-
-      // Protocol-specific table rendering
-      if (adapterName === "modbus") {
-        renderModbusTable(tags);
-      } else if (adapterName === "opcua") {
-        renderOpcuaTable(tags);
-      } else {
-        renderMqttTable(tags);
-      }
-    } catch (error) {
-      handleCommandError(error);
-    }
-  };
-
-  adapter
-    .command("inspect [name]")
-    .description("Inspect a running adapter's tag map (default: modbus)")
-    .option("--json", "Machine-readable JSON output")
-    .option("--admin-url <url>", "Admin API URL (env: MIRAVO_ADMIN_URL)")
-    .option("--timeout <seconds>", "Timeout in seconds (default: 5)", parseTimeoutSeconds)
-    .addHelpText(
-      "after",
-      `
-Examples:
-  $ miravo adapter inspect modbus          Show Modbus register map
-  $ miravo adapter inspect opcua           Show OPC UA node map
-  $ miravo adapter inspect mqtt            Show MQTT topic map
-  $ miravo adapter inspect --json          JSON output for scripting`,
-    )
-    .action(inspectAction);
-}
-
-function renderModbusTable(tags: Array<Record<string, unknown>>): void {
-  const instanceCount = new Set(tags.map((s) => s["instance"])).size;
-  modbusLog.info(
-    `Register Map — ${colors.bold(String(tags.length))} entries, ${colors.bold(String(instanceCount))} instances`,
-  );
-  writeOutput();
-
-  const rows = tags.map((s) => {
-    const modbus = (s["protocols"] as Record<string, Record<string, unknown>>)?.["modbus"] ?? {};
-    return {
-      address: String(modbus["address"] ?? ""),
-      count: String(modbus["count"] ?? ""),
-      instance: String(s["instance"] ?? ""),
-      member: String(s["member"] ?? ""),
-      type: String(modbus["registerType"] ?? ""),
-      access: String(s["access"] ?? ""),
-    };
-  });
-
-  writeOutput(
-    formatTable(
-      {
-        address: colors.dim("Address"),
-        count: colors.dim("Regs"),
-        instance: colors.dim("Instance"),
-        member: colors.dim("Member"),
-        type: colors.dim("Type"),
-        access: colors.dim("Access"),
-      },
-      rows,
-    ),
-  );
-  writeOutput();
-}
-
-function renderOpcuaTable(tags: Array<Record<string, unknown>>): void {
-  const instanceCount = new Set(tags.map((s) => s["instance"])).size;
-  engineLog.info(
-    `OPC UA — ${colors.bold(String(tags.length))} tags, ${colors.bold(String(instanceCount))} instances`,
-  );
-  writeOutput();
-
-  const rows = tags.map((s) => {
-    const opcua = (s["protocols"] as Record<string, Record<string, unknown>>)?.["opcua"] ?? {};
-    return {
-      nodeId: String(opcua["nodeId"] ?? ""),
-      instance: String(s["instance"] ?? ""),
-      member: String(s["member"] ?? ""),
-      dataType: String(s["dataType"] ?? ""),
-      access: String(s["access"] ?? ""),
-    };
-  });
-
-  writeOutput(
-    formatTable(
-      {
-        nodeId: colors.dim("NodeId"),
-        instance: colors.dim("Instance"),
-        member: colors.dim("Member"),
-        dataType: colors.dim("Type"),
-        access: colors.dim("Access"),
-      },
-      rows,
-    ),
-  );
-  writeOutput();
-}
-
-function renderMqttTable(tags: Array<Record<string, unknown>>): void {
-  const instanceCount = new Set(tags.map((s) => s["instance"])).size;
-  engineLog.info(
-    `MQTT — ${colors.bold(String(tags.length))} tags, ${colors.bold(String(instanceCount))} instances`,
-  );
-  writeOutput();
-
-  const rows = tags.map((s) => {
-    const mqtt = (s["protocols"] as Record<string, Record<string, unknown>>)?.["mqtt"] ?? {};
-    return {
-      topic: String(mqtt["topic"] ?? ""),
-      instance: String(s["instance"] ?? ""),
-      member: String(s["member"] ?? ""),
-      dataType: String(s["dataType"] ?? ""),
-      access: String(s["access"] ?? ""),
-      unit: String(s["unit"] ?? ""),
-    };
-  });
-
-  writeOutput(
-    formatTable(
-      {
-        topic: colors.dim("Topic"),
-        instance: colors.dim("Instance"),
-        member: colors.dim("Member"),
-        dataType: colors.dim("Type"),
-        access: colors.dim("Access"),
-        unit: colors.dim("Unit"),
-      },
-      rows,
-    ),
-  );
-  writeOutput();
-}

package/src/commands/apply.test.ts

@@ -1,62 +0,0 @@
-import { afterEach, beforeEach, expect, test } from "bun:test";
-import { resetExitCode, runCliCommand } from "./cli-test-setup.ts";
-
-beforeEach(resetExitCode);
-afterEach(resetExitCode);
-
-test("apply le rejects invalid --scope values", async () => {
-  await runCliCommand([
-    "apply",
-    "le",
-    "--template",
-    "smart-factory",
-    "--source-hostname",
-    "10.0.0.1",
-    "--le-hostname",
-    "le.example.local",
-    "--le-api-token",
-    "token",
-    "--scope",
-    "foo,bar",
-  ]);
-
-  expect(process.exitCode).toBe(1);
-});
-
-test("apply le rejects invalid --if-unmanaged values", async () => {
-  await runCliCommand([
-    "apply",
-    "le",
-    "--template",
-    "smart-factory",
-    "--source-hostname",
-    "10.0.0.1",
-    "--le-hostname",
-    "le.example.local",
-    "--le-api-token",
-    "token",
-    "--if-unmanaged",
-    "ignore",
-  ]);
-
-  expect(process.exitCode).toBe(1);
-});
-
-test("apply le rejects invalid --protocol values", async () => {
-  await runCliCommand([
-    "apply",
-    "le",
-    "--template",
-    "smart-factory",
-    "--source-hostname",
-    "10.0.0.1",
-    "--le-hostname",
-    "le.example.local",
-    "--le-api-token",
-    "token",
-    "--protocol",
-    "http",
-  ]);
-
-  expect(process.exitCode).toBe(1);
-});