miravo 0.6.0 → 0.6.2

package/src/commands/platforms.test.ts

@@ -1,186 +0,0 @@
-import { afterEach, beforeEach, describe, expect, spyOn, test } from "bun:test";
-import { mkdtemp, rm } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { addEnvironment, loadEnvironments } from "../lib/le/le-environments.ts";
-import { configureLogger, lockLogger, unlockLogger } from "../logger.ts";
-import { findCliCommand, resetExitCode, runCliCommand } from "./cli-test-setup.ts";
-
-let testHome = "";
-let prevMiravoHome: string | undefined;
-const originalFetch = globalThis.fetch;
-
-beforeEach(async () => {
-  resetExitCode();
-  prevMiravoHome = Bun.env["MIRAVO_HOME"];
-  testHome = await mkdtemp(join(tmpdir(), "miravo-env-command-test-"));
-  Bun.env["MIRAVO_HOME"] = testHome;
-});
-
-afterEach(async () => {
-  globalThis.fetch = originalFetch;
-  if (prevMiravoHome === undefined) {
-    delete Bun.env["MIRAVO_HOME"];
-  } else {
-    Bun.env["MIRAVO_HOME"] = prevMiravoHome;
-  }
-  resetExitCode();
-  if (testHome) {
-    await rm(testHome, { recursive: true, force: true });
-  }
-});
-
-describe("miravo platforms env", () => {
-  test("platforms command is registered with env subcommand", async () => {
-    const { cmd } = await findCliCommand("platforms");
-    const env = cmd?.commands.find((command) => command.name() === "env");
-    expect(cmd).toBeDefined();
-    expect(env).toBeDefined();
-    expect(env?.aliases()).toContain("environments");
-  });
-
-  test("add stores an environment and inspect masks token by default", async () => {
-    unlockLogger();
-    configureLogger({ plain: true });
-    lockLogger();
-    using logSpy = spyOn(console, "log").mockImplementation(() => {});
-
-    await runCliCommand([
-      "platforms",
-      "env",
-      "add",
-      "--label",
-      "Prod",
-      "--hostname",
-      "le.example.local",
-      "--api-token",
-      "super-secret-token",
-      "--source-hostname",
-      "miravo.local",
-    ]);
-
-    const envs = await loadEnvironments();
-    expect(envs).toHaveLength(1);
-    expect(envs[0]?.label).toBe("Prod");
-    expect(process.exitCode).toBe(0);
-
-    logSpy.mockClear();
-    await runCliCommand(["platforms", "env", "inspect", "Prod"]);
-
-    const output = logSpy.mock.calls.map((call) => call.join(" ")).join("\n");
-    expect(output).toContain("Prod");
-    expect(output).toContain("••••");
-    expect(output).not.toContain("super-secret-token");
-  });
-
-  test("inspect --show-token prints full token", async () => {
-    const created = await addEnvironment({
-      platformId: "litmus-edge",
-      label: "Prod",
-      hostname: "le.example.local",
-      apiToken: "super-secret-token",
-      sourceHostname: "miravo.local",
-    });
-    unlockLogger();
-    configureLogger({ plain: true });
-    lockLogger();
-    using logSpy = spyOn(console, "log").mockImplementation(() => {});
-
-    await runCliCommand(["platforms", "env", "inspect", created.id, "--show-token"]);
-
-    const output = logSpy.mock.calls.map((call) => call.join(" ")).join("\n");
-    expect(output).toContain("super-secret-token");
-  });
-
-  test("update resolves by label and updates the environment", async () => {
-    await addEnvironment({
-      platformId: "litmus-edge",
-      label: "Prod",
-      hostname: "le.example.local",
-      apiToken: "super-secret-token",
-      sourceHostname: "miravo.local",
-    });
-
-    await runCliCommand(["platforms", "env", "update", "Prod", "--hostname", "new.example.local"]);
-
-    const envs = await loadEnvironments();
-    expect(envs[0]?.hostname).toBe("new.example.local");
-    expect(process.exitCode).toBe(0);
-  });
-
-  test("remove resolves by id and deletes the environment", async () => {
-    const created = await addEnvironment({
-      platformId: "litmus-edge",
-      label: "Prod",
-      hostname: "le.example.local",
-      apiToken: "super-secret-token",
-      sourceHostname: "miravo.local",
-    });
-
-    await runCliCommand(["platforms", "env", "remove", created.id, "--yes"]);
-
-    const envs = await loadEnvironments();
-    expect(envs).toHaveLength(0);
-    expect(process.exitCode).toBe(0);
-  });
-
-  test("inspect fails when label is ambiguous", async () => {
-    await addEnvironment({
-      platformId: "litmus-edge",
-      label: "Prod",
-      hostname: "le-1.example.local",
-      apiToken: "token-1",
-      sourceHostname: "miravo.local",
-    });
-    await addEnvironment({
-      platformId: "litmus-edge",
-      label: "prod",
-      hostname: "le-2.example.local",
-      apiToken: "token-2",
-      sourceHostname: "miravo.local",
-    });
-
-    await runCliCommand(["platforms", "env", "inspect", "Prod"]);
-
-    expect(process.exitCode).toBe(1);
-  });
-
-  test("test succeeds for a reachable environment", async () => {
-    await addEnvironment({
-      platformId: "litmus-edge",
-      label: "Prod",
-      hostname: "le.example.local",
-      apiToken: "super-secret-token",
-      sourceHostname: "miravo.local",
-    });
-    globalThis.fetch = (async (input) => {
-      const url = String(input);
-      expect(url).toContain("/sysinfo/version");
-      return Response.json({ version: "1.0.0" }, { status: 200 });
-    }) as typeof fetch;
-    unlockLogger();
-    configureLogger({ plain: true });
-    lockLogger();
-    using logSpy = spyOn(console, "log").mockImplementation(() => {});
-
-    await runCliCommand(["platforms", "env", "test", "Prod"]);
-
-    const output = logSpy.mock.calls.map((call) => call.join(" ")).join("\n");
-    expect(output).toContain("connected");
-    expect(process.exitCode).toBe(0);
-  });
-
-  test("test fails for unsupported platform ids", async () => {
-    await addEnvironment({
-      platformId: "coming-soon-platform",
-      label: "Future",
-      hostname: "future.example.local",
-      apiToken: "super-secret-token",
-      sourceHostname: "miravo.local",
-    });
-
-    await runCliCommand(["platforms", "env", "test", "Future"]);
-
-    expect(process.exitCode).toBe(1);
-  });
-});

package/src/commands/platforms.ts

@@ -1,371 +0,0 @@
-import { confirm, isCancel } from "@clack/prompts";
-import { MiravoError } from "@miravo/shared";
-import type { Command } from "commander";
-import { colors } from "consola/utils";
-import {
-  assertSupportedEnvironmentPlatform,
-  testLeConnection,
-} from "../lib/le/le-connection-test.ts";
-import {
-  addEnvironment,
-  DEFAULT_PLATFORM_ID,
-  getEnvironment,
-  getEnvironmentByLabel,
-  type LEEnvironment,
-  loadEnvironments,
-  removeEnvironment,
-  updateEnvironment,
-} from "../lib/le/le-environments.ts";
-import { handleCommandError, writeOutput } from "../logger.ts";
-import { formatKeyValue, formatTable } from "../output.ts";
-
-interface SharedOptions {
-  readonly json?: boolean;
-}
-
-interface AddEnvironmentOptions extends SharedOptions {
-  readonly label?: string;
-  readonly hostname?: string;
-  readonly apiToken?: string;
-  readonly sourceHostname?: string;
-  readonly platform?: string;
-}
-
-interface UpdateEnvironmentOptions extends SharedOptions {
-  readonly label?: string;
-  readonly hostname?: string;
-  readonly apiToken?: string;
-  readonly sourceHostname?: string;
-  readonly platform?: string;
-}
-
-interface InspectEnvironmentOptions extends SharedOptions {
-  readonly showToken?: boolean;
-}
-
-interface RemoveEnvironmentOptions {
-  readonly yes?: boolean;
-}
-
-function maskToken(token: string): string {
-  if (token.length <= 8) return "••••••••";
-  return `${"•".repeat(token.length - 4)}${token.slice(-4)}`;
-}
-
-function userError(message: string, fix: string): MiravoError {
-  return new MiravoError(message, fix);
-}
-
-async function resolveEnvironmentByIdOrLabel(idOrLabel: string): Promise<LEEnvironment> {
-  const byId = await getEnvironment(idOrLabel);
-  if (byId) return byId;
-
-  const envs = await loadEnvironments();
-  const lower = idOrLabel.toLowerCase();
-  const labelMatches = envs.filter((env) => env.label.toLowerCase() === lower);
-
-  if (labelMatches.length === 1) return labelMatches[0] as LEEnvironment;
-  if (labelMatches.length > 1) {
-    const ids = labelMatches.map((env) => env.id).join(", ");
-    throw userError(
-      `Multiple environments use label "${idOrLabel}".`,
-      `Use an id instead (${ids}).`,
-    );
-  }
-
-  throw userError(
-    `Environment "${idOrLabel}" not found.`,
-    "Use 'miravo platforms env list' to inspect ids and labels.",
-  );
-}
-
-function printEnvironmentDetails(
-  env: LEEnvironment,
-  options: {
-    readonly json?: boolean | undefined;
-    readonly showToken?: boolean | undefined;
-  },
-): void {
-  const token = options.showToken ? env.apiToken : maskToken(env.apiToken);
-  if (options.json) {
-    writeOutput(
-      JSON.stringify(
-        {
-          ...env,
-          apiToken: token,
-        },
-        null,
-        2,
-      ),
-    );
-    return;
-  }
-
-  writeOutput(
-    formatKeyValue([
-      ["Id", env.id],
-      ["Label", env.label],
-      ["Platform", env.platformId],
-      ["Hostname", env.hostname],
-      ["Source Host", env.sourceHostname],
-      ["API Token", token],
-      ["Last Used", env.lastUsedAt ? new Date(env.lastUsedAt).toISOString() : "never"],
-    ]),
-  );
-}
-
-function printEnvironmentList(
-  envs: readonly LEEnvironment[],
-  jsonOutput: boolean | undefined,
-): void {
-  if (jsonOutput) {
-    writeOutput(
-      JSON.stringify(
-        envs.map((env) => ({
-          ...env,
-          apiToken: maskToken(env.apiToken),
-        })),
-        null,
-        2,
-      ),
-    );
-    return;
-  }
-
-  if (envs.length === 0) {
-    writeOutput("No environments configured.");
-    return;
-  }
-
-  writeOutput(
-    formatTable(
-      {
-        id: colors.dim("Id"),
-        label: colors.dim("Label"),
-        platform: colors.dim("Platform"),
-        hostname: colors.dim("Hostname"),
-        sourceHost: colors.dim("Source Host"),
-        lastUsed: colors.dim("Last Used"),
-      },
-      envs.map((env) => ({
-        id: env.id,
-        label: env.label,
-        platform: env.platformId,
-        hostname: env.hostname,
-        sourceHost: env.sourceHostname,
-        lastUsed: env.lastUsedAt ? new Date(env.lastUsedAt).toISOString() : "never",
-      })),
-    ),
-  );
-}
-
-function assertSupportedPlatform(platformId: string): void {
-  if (platformId !== DEFAULT_PLATFORM_ID) {
-    throw userError(
-      `Unsupported platform "${platformId}". Only "${DEFAULT_PLATFORM_ID}" is currently supported.`,
-      `Use --platform ${DEFAULT_PLATFORM_ID}.`,
-    );
-  }
-}
-
-export function registerEnvironmentsCommand(program: Command): void {
-  const platforms = program
-    .command("platforms")
-    .description("Manage platform integrations and saved environments");
-
-  const env = platforms
-    .command("env")
-    .alias("environments")
-    .description("Manage saved platform environments");
-
-  env
-    .command("list")
-    .description("List configured environments")
-    .option("--json", "Machine-readable JSON output")
-    .action(async (options: SharedOptions) => {
-      try {
-        const envs = await loadEnvironments();
-        printEnvironmentList(envs, options.json);
-      } catch (error) {
-        handleCommandError(error);
-      }
-    });
-
-  env
-    .command("add")
-    .description("Add a new environment")
-    .requiredOption("--label <label>", "Environment label")
-    .requiredOption("--hostname <host>", "Litmus Edge hostname or IP")
-    .requiredOption("--api-token <token>", "Litmus Edge API token")
-    .requiredOption("--source-hostname <host>", "Hostname LE uses to reach Miravo")
-    .option("--platform <id>", `Platform id (default: ${DEFAULT_PLATFORM_ID})`, DEFAULT_PLATFORM_ID)
-    .option("--json", "Machine-readable JSON output")
-    .action(async (options: AddEnvironmentOptions) => {
-      try {
-        const platformId = options.platform ?? DEFAULT_PLATFORM_ID;
-        assertSupportedPlatform(platformId);
-
-        const existing = await getEnvironmentByLabel(options.label as string);
-        if (existing) {
-          throw userError(
-            `Environment label "${options.label}" already exists. Use 'miravo platforms env update ${existing.id}' instead.`,
-            `Choose a different --label or update ${existing.id}.`,
-          );
-        }
-
-        const created = await addEnvironment({
-          platformId,
-          label: options.label as string,
-          hostname: options.hostname as string,
-          apiToken: options.apiToken as string,
-          sourceHostname: options.sourceHostname as string,
-        });
-        printEnvironmentDetails(created, { json: options.json });
-      } catch (error) {
-        handleCommandError(error);
-      }
-    });
-
-  env
-    .command("inspect <idOrLabel>")
-    .description("Inspect an environment by id or label")
-    .option("--show-token", "Print the full API token", false)
-    .option("--json", "Machine-readable JSON output")
-    .action(async (idOrLabel: string, options: InspectEnvironmentOptions) => {
-      try {
-        const resolved = await resolveEnvironmentByIdOrLabel(idOrLabel);
-        printEnvironmentDetails(resolved, options);
-      } catch (error) {
-        handleCommandError(error);
-      }
-    });
-
-  env
-    .command("update <idOrLabel>")
-    .description("Update an environment by id or label")
-    .option("--label <label>", "New environment label")
-    .option("--hostname <host>", "New Litmus Edge hostname or IP")
-    .option("--api-token <token>", "New Litmus Edge API token")
-    .option("--source-hostname <host>", "New hostname LE uses to reach Miravo")
-    .option("--platform <id>", "New platform id")
-    .option("--json", "Machine-readable JSON output")
-    .action(async (idOrLabel: string, options: UpdateEnvironmentOptions) => {
-      try {
-        const resolved = await resolveEnvironmentByIdOrLabel(idOrLabel);
-        const hasUpdates =
-          options.label !== undefined ||
-          options.hostname !== undefined ||
-          options.apiToken !== undefined ||
-          options.sourceHostname !== undefined ||
-          options.platform !== undefined;
-        if (!hasUpdates) {
-          throw userError(
-            "No updates provided.",
-            "Pass at least one of --label, --hostname, --api-token, --source-hostname, or --platform.",
-          );
-        }
-        if (options.platform !== undefined) {
-          assertSupportedPlatform(options.platform);
-        }
-        if (options.label !== undefined) {
-          const byLabel = await getEnvironmentByLabel(options.label);
-          if (byLabel && byLabel.id !== resolved.id) {
-            throw userError(
-              `Environment label "${options.label}" already exists. Choose a different label.`,
-              "Choose a unique --label value.",
-            );
-          }
-        }
-
-        const updated = await updateEnvironment(resolved.id, {
-          platformId: options.platform,
-          label: options.label,
-          hostname: options.hostname,
-          apiToken: options.apiToken,
-          sourceHostname: options.sourceHostname,
-        });
-        if (!updated) {
-          throw userError(
-            `Environment "${resolved.id}" not found.`,
-            "Run 'miravo platforms env list' and retry with an existing id.",
-          );
-        }
-        printEnvironmentDetails(updated, { json: options.json });
-      } catch (error) {
-        handleCommandError(error);
-      }
-    });
-
-  env
-    .command("remove <idOrLabel>")
-    .description("Remove an environment by id or label")
-    .option("--yes", "Skip confirmation prompt", false)
-    .action(async (idOrLabel: string, options: RemoveEnvironmentOptions) => {
-      try {
-        const resolved = await resolveEnvironmentByIdOrLabel(idOrLabel);
-        if (!options.yes) {
-          const confirmed = await confirm({
-            message: `Remove environment "${resolved.label}" (${resolved.id})?`,
-          });
-          if (isCancel(confirmed) || confirmed !== true) {
-            writeOutput("Canceled.");
-            return;
-          }
-        }
-
-        const removed = await removeEnvironment(resolved.id);
-        if (!removed) {
-          throw userError(
-            `Environment "${resolved.id}" not found.`,
-            "Run 'miravo platforms env list' and retry with an existing id.",
-          );
-        }
-        writeOutput(`Removed environment "${resolved.label}" (${resolved.id}).`);
-      } catch (error) {
-        handleCommandError(error);
-      }
-    });
-
-  env
-    .command("test <idOrLabel>")
-    .description("Test connectivity for an environment by id or label")
-    .option("--json", "Machine-readable JSON output")
-    .action(async (idOrLabel: string, options: SharedOptions) => {
-      try {
-        const resolved = await resolveEnvironmentByIdOrLabel(idOrLabel);
-        assertSupportedEnvironmentPlatform(resolved);
-        const result = await testLeConnection({
-          hostname: resolved.hostname,
-          apiToken: resolved.apiToken,
-          sourceHostname: resolved.sourceHostname,
-        });
-
-        if (options.json) {
-          writeOutput(JSON.stringify(result, null, 2));
-          if (!result.connected) process.exitCode = 1;
-          return;
-        }
-
-        if (result.connected) {
-          writeOutput(
-            formatKeyValue([
-              ["Status", "connected"],
-              ["Hostname", result.hostname],
-              ["Source Host", result.sourceHostname],
-            ]),
-          );
-          return;
-        }
-
-        writeOutput(
-          formatKeyValue([
-            ["Status", "failed"],
-            ["Error", result.error],
-          ]),
-        );
-        process.exitCode = 1;
-      } catch (error) {
-        handleCommandError(error);
-      }
-    });
-}

package/src/commands/ps.ts

@@ -1,116 +0,0 @@
-import type { EngineMetricsSnapshot } from "@miravo/shared";
-import type { Command } from "commander";
-import { isPidAlive, listEntries, sweepStaleEntries } from "../lib/daemon-registry.ts";
-import { handleCommandError, writeOutput } from "../logger.ts";
-import { formatTable } from "../output.ts";
-
-interface PsOptions {
-  readonly json?: boolean;
-}
-
-export function registerPsCommand(program: Command): void {
-  program
-    .command("ps")
-    .description("List background simulations with live metrics")
-    .option("--json", "Machine-readable JSON output")
-    .addHelpText(
-      "after",
-      `
-Examples:
-  $ miravo ps                              List background simulations
-  $ miravo ps --json                       Machine-readable JSON output`,
-    )
-    .action(async (options: PsOptions) => {
-      try {
-        await psAction(options);
-      } catch (error) {
-        handleCommandError(error);
-      }
-    });
-}
-
-type PsRow = Record<string, string> & {
-  readonly name: string;
-  readonly status: string;
-  readonly uptime: string;
-  readonly ticks: string;
-  readonly instances: string;
-  readonly admin: string;
-  readonly mqtt: string;
-  readonly opcua: string;
-};
-
-async function psAction(options: PsOptions): Promise<void> {
-  await sweepStaleEntries();
-  const entries = await listEntries();
-
-  if (entries.length === 0) {
-    writeOutput("No running simulations.");
-    return;
-  }
-
-  const rows: PsRow[] = [];
-
-  for (const entry of entries) {
-    const alive = isPidAlive(entry.pid);
-    let status = alive ? "running" : "dead";
-    let uptime = "-";
-    let ticks = "-";
-    let instances = "-";
-
-    if (alive) {
-      try {
-        const url = `http://${entry.adminHost}:${entry.adminPort}/metrics`;
-        const response = await fetch(url, { signal: AbortSignal.timeout(2_000) });
-        if (response.ok) {
-          const metrics = (await response.json()) as EngineMetricsSnapshot;
-          status = metrics.core.state === "running" ? "running" : metrics.core.state;
-          uptime = formatUptime(metrics.core.uptimeMs);
-          ticks = String(metrics.core.tickCount);
-          instances = String(metrics.core.instanceCount);
-        }
-      } catch {
-        status = "starting";
-      }
-    }
-
-    const mqttAdapter = entry.adapters["mqtt"];
-    const opcuaAdapter = entry.adapters["opcua"];
-
-    rows.push({
-      name: entry.name,
-      status,
-      uptime,
-      ticks,
-      instances,
-      admin: `:${entry.adminPort}`,
-      mqtt: mqttAdapter ? `:${mqttAdapter.port}` : "-",
-      opcua: opcuaAdapter ? `:${opcuaAdapter.port}` : "-",
-    });
-  }
-
-  if (options.json) {
-    writeOutput(JSON.stringify(rows, null, 2));
-    return;
-  }
-
-  const headers: Record<string, string> = {
-    name: "NAME",
-    status: "STATUS",
-    uptime: "UPTIME",
-    ticks: "TICKS",
-    instances: "INSTANCES",
-    admin: "ADMIN",
-    mqtt: "MQTT",
-    opcua: "OPC UA",
-  };
-
-  writeOutput(formatTable(headers, rows));
-}
-
-function formatUptime(ms: number): string {
-  const totalSeconds = Math.floor(ms / 1_000);
-  const hours = Math.floor(totalSeconds / 3_600);
-  const minutes = Math.floor((totalSeconds % 3_600) / 60);
-  return `${hours}h ${String(minutes).padStart(2, "0")}m`;
-}