miravo 0.6.0 → 0.6.2

package/src/commands/inject.ts

@@ -1,212 +0,0 @@
-import { confirm, intro, isCancel, outro, select } from "@clack/prompts";
-import type { EngineCommand } from "@miravo/shared";
-import { CONTROL_CMD_TIMEOUT_MS, MiravoError } from "@miravo/shared";
-import type { Command } from "commander";
-import { executeAdminCommand, getAdminState, resolveAdminUrl } from "../lib/admin-client.ts";
-import { parseTimeoutSeconds } from "../lib/parse.ts";
-import { faultLog, handleCommandError } from "../logger.ts";
-
-interface InjectOptions {
-  readonly clear?: boolean;
-  readonly json?: boolean;
-  readonly name?: string;
-  readonly adminUrl?: string;
-  readonly timeout?: number;
-}
-
-/**
- * Register the `miravo inject` command with the root Commander program.
- * Triggers or clears a fault on a running twin instance via the admin HTTP server.
- */
-export function registerInjectCommand(program: Command): void {
-  program
-    .command("inject [instanceId] [fault]")
-    .description("Trigger or clear a fault on a running instance (interactive if no args)")
-    .option("--clear", "Clear the fault instead of triggering it")
-    .option("--json", "Machine-readable JSON output")
-    .option("--name <name>", "Target simulation name")
-    .option("--admin-url <url>", "Admin API URL (env: MIRAVO_ADMIN_URL)")
-    .option("--timeout <seconds>", "Timeout in seconds (default: 5)", parseTimeoutSeconds)
-    .addHelpText(
-      "after",
-      `
-Examples:
-  $ miravo inject                          Interactive mode (pick instance + fault)
-  $ miravo inject pump-001 cavitation      Trigger fault directly
-  $ miravo inject pump-001 cavitation --clear  Clear an active fault`,
-    )
-    .action(
-      async (instanceId: string | undefined, fault: string | undefined, options: InjectOptions) => {
-        await injectAction(instanceId, fault, options);
-      },
-    );
-}
-
-// ---------------------------------------------------------------------------
-// Action
-// ---------------------------------------------------------------------------
-
-async function injectAction(
-  instanceId: string | undefined,
-  fault: string | undefined,
-  options: InjectOptions,
-): Promise<void> {
-  // Fail fast before broker connect when interactive prompts would be required.
-  if ((!instanceId || !fault) && (!process.stdout.isTTY || !process.stdin.isTTY)) {
-    faultLog.error("Interactive mode requires a terminal. Usage: miravo inject <instance> <fault>");
-    process.exitCode = 1;
-    return;
-  }
-
-  try {
-    const timeoutMs = options.timeout ?? CONTROL_CMD_TIMEOUT_MS;
-    const adminUrl = resolveAdminUrl(options.adminUrl);
-    const stateResult = await getTargetState(adminUrl, timeoutMs, options.name);
-
-    let targetInstance = instanceId;
-    let targetFault = fault;
-
-    // Interactive mode: pick instance and fault via prompts
-    if (!targetInstance || !targetFault) {
-      if (!process.stdout.isTTY || !process.stdin.isTTY) {
-        faultLog.error(
-          "Interactive mode requires a terminal. Usage: miravo inject <instance> <fault>",
-        );
-        process.exitCode = 1;
-        return;
-      }
-
-      const picked = await pickInstanceAndFault(stateResult, options.clear ?? false);
-      if (!picked) return;
-
-      targetInstance = picked.instanceId;
-      targetFault = picked.fault;
-    }
-
-    const command: EngineCommand = options.clear
-      ? { type: "clearFault", instanceId: targetInstance, fault: targetFault }
-      : { type: "triggerFault", instanceId: targetInstance, fault: targetFault };
-
-    const result = await executeAdminCommand(adminUrl, command, timeoutMs);
-
-    if (options.json) {
-      console.log(JSON.stringify(result, null, 2));
-    } else if (result.success) {
-      faultLog.success(result.message);
-    } else {
-      faultLog.error(result.message);
-      if (result.error) {
-        faultLog.error(`Fix: ${result.error}`);
-      }
-    }
-    if (!result.success) process.exitCode = 1;
-  } catch (error) {
-    handleCommandError(error, faultLog);
-  }
-}
-
-// ---------------------------------------------------------------------------
-// Read state snapshot from admin server
-// ---------------------------------------------------------------------------
-
-interface StateSnapshot {
-  readonly models: ReadonlyArray<{
-    readonly name: string;
-    readonly faultNames: readonly string[];
-  }>;
-  readonly instances: ReadonlyArray<{
-    readonly id: string;
-    readonly model: string;
-    readonly lifecycleStage: string;
-    readonly activeFaults: readonly string[];
-  }>;
-}
-
-async function getTargetState(
-  adminUrl: string,
-  timeoutMs: number,
-  expectedName?: string,
-): Promise<StateSnapshot> {
-  const state = await getAdminState(adminUrl, timeoutMs);
-  if (expectedName && state.simulationName !== expectedName) {
-    throw new MiravoError(
-      `Connected to simulation "${state.simulationName}" instead of "${expectedName}".`,
-      "Pass --admin-url for the correct Miravo process, or omit --name to target the connected simulation.",
-    );
-  }
-  return state as StateSnapshot;
-}
-
-// ---------------------------------------------------------------------------
-// Interactive: pick instance and fault
-// ---------------------------------------------------------------------------
-
-async function pickInstanceAndFault(
-  state: StateSnapshot,
-  clearing: boolean,
-): Promise<{ instanceId: string; fault: string } | null> {
-  if (state.instances.length === 0) {
-    faultLog.error("No instances running. Spawn instances first with 'miravo start'.");
-    process.exitCode = 1;
-    return null;
-  }
-
-  intro(clearing ? "Clear a fault" : "Inject a fault");
-
-  // Pick instance
-  const instanceChoice = await select({
-    message: "Which instance?",
-    options: state.instances.map((inst) => ({
-      value: inst.id,
-      label: inst.id,
-      hint: `${inst.model} · ${inst.lifecycleStage}${inst.activeFaults.length > 0 ? ` · faults: ${inst.activeFaults.join(", ")}` : ""}`,
-    })),
-  });
-
-  if (isCancel(instanceChoice)) {
-    outro("Cancelled.");
-    return null;
-  }
-
-  const selectedInstance = state.instances.find((i) => i.id === instanceChoice);
-  if (!selectedInstance) return null;
-
-  // Get available faults for this instance's model
-  const model = state.models.find((m) => m.name === selectedInstance.model);
-  const availableFaults = clearing ? selectedInstance.activeFaults : (model?.faultNames ?? []);
-
-  if (availableFaults.length === 0) {
-    const reason = clearing
-      ? `No active faults on ${selectedInstance.id}.`
-      : `Model "${selectedInstance.model}" has no defined faults.`;
-    outro(reason);
-    return null;
-  }
-
-  // Pick fault
-  const faultChoice = await select({
-    message: clearing ? "Which fault to clear?" : "Which fault to trigger?",
-    options: availableFaults.map((f) => ({
-      value: f,
-      label: f,
-    })),
-  });
-
-  if (isCancel(faultChoice)) {
-    outro("Cancelled.");
-    return null;
-  }
-
-  // Confirm
-  const action = clearing ? "Clear" : "Trigger";
-  const confirmed = await confirm({
-    message: `${action} ${faultChoice as string} on ${instanceChoice as string}?`,
-  });
-
-  if (isCancel(confirmed) || !confirmed) {
-    outro("Cancelled.");
-    return null;
-  }
-
-  return { instanceId: instanceChoice as string, fault: faultChoice as string };
-}

package/src/commands/load.ts

@@ -1,167 +0,0 @@
-import { basename } from "node:path";
-import { isCancel, select } from "@clack/prompts";
-import type { ContentCatalog } from "@miravo/core";
-import { discoverTemplates } from "@miravo/core";
-import type { DiscoveredTemplate, EngineCommand } from "@miravo/shared";
-import { CONTROL_CMD_TIMEOUT_MS, ConfigNotFoundError, MiravoError } from "@miravo/shared";
-import type { Command } from "commander";
-import { executeAdminCommand, resolveAdminUrl } from "../lib/admin-client.ts";
-import { parsePositiveInt, parseTimeoutSeconds } from "../lib/parse.ts";
-import { isStressBenchmarkTemplate } from "../lib/template-category.ts";
-import {
-  createCatalog,
-  discoverPreferredLocalTemplates,
-  resolveTemplateIdentifier,
-} from "../lib/template-locator.ts";
-import { configLog, handleCommandError, handleCommandResult } from "../logger.ts";
-
-interface LoadOptions {
-  readonly template?: string;
-  readonly count?: number;
-  readonly json?: boolean;
-  readonly adminUrl?: string;
-  readonly timeout?: number;
-}
-
-export function registerLoadCommand(program: Command): void {
-  program
-    .command("load")
-    .description("Add instances from a template to the running simulation")
-    .option(
-      "-t, --template <id|name|path,...>",
-      "Template id, name, path, or comma-separated list (env: MIRAVO_TEMPLATE)",
-    )
-    .option(
-      "-c, --count <n>",
-      "Number of template copies to load per template (default: 1)",
-      parsePositiveInt,
-    )
-    .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 load -t smart-factory                     Load built-in template by name
-  $ miravo load -t ./extra.miravo.yaml               Load template from file
-  $ miravo load -t smart-factory,water-treatment     Load two templates at once
-  $ miravo load -t smart-factory -c 3               Load 3 copies of a template
-  $ miravo load                                      Auto-discover and load`,
-    )
-    .action(async (options: LoadOptions) => {
-      try {
-        const catalog = createCatalog();
-        const templateIdentifier = options.template ?? Bun.env["MIRAVO_TEMPLATE"];
-
-        let templatePaths: string[];
-        if (templateIdentifier !== undefined) {
-          const identifiers = templateIdentifier
-            .split(",")
-            .map((s) => s.trim())
-            .filter(Boolean);
-          templatePaths = await Promise.all(
-            identifiers.map((id) => resolveTemplateIdentifier(id, catalog)),
-          );
-        } else {
-          const path = await resolveLoadTemplatePath(catalog);
-          templatePaths = [path];
-        }
-
-        const adminUrl = resolveAdminUrl(options.adminUrl);
-        const timeoutMs = options.timeout ?? CONTROL_CMD_TIMEOUT_MS;
-
-        for (const templatePath of templatePaths) {
-          const command: EngineCommand = {
-            type: "loadTemplate",
-            templatePath,
-            count: options.count ?? 1,
-          };
-          const result = await executeAdminCommand(adminUrl, command, timeoutMs);
-          handleCommandResult(result, options.json);
-        }
-      } catch (error) {
-        handleCommandError(error);
-      }
-    });
-}
-
-async function resolveLoadTemplatePath(catalog: ContentCatalog): Promise<string> {
-  // 1. Auto-discover local templates (CWD + local registry)
-  const discovered = await discoverPreferredLocalTemplates(catalog);
-  if (discovered.length === 1) {
-    const first = discovered[0];
-    if (first !== undefined) {
-      configLog.info(`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;
-    }
-  }
-
-  // 2. Fall back to built-in templates
-  const builtinTemplateDir = catalog.getBuiltinTemplatesDir();
-  let builtinTemplates: readonly DiscoveredTemplate[] = [];
-  try {
-    const all = await discoverTemplates(builtinTemplateDir);
-    builtinTemplates = all.filter((t) => !isStressBenchmarkTemplate(t.id));
-  } catch {
-    // Builtin dir may not exist in edge cases
-  }
-  if (builtinTemplates.length > 0) {
-    if (process.stdout.isTTY && process.stdin.isTTY) {
-      return pickBuiltinTemplate(builtinTemplates);
-    }
-    const selected =
-      builtinTemplates.find((t) => basename(t.path) === "smart-factory.miravo.yaml") ??
-      builtinTemplates[0];
-    if (selected !== undefined) {
-      configLog.info(`No template specified. Using built-in "${selected.name}".`);
-      configLog.info(
-        "Run 'miravo templates list' to see all options, or use --template <name|path>.",
-      );
-      return selected.path;
-    }
-  }
-
-  // 3. Nothing available
-  throw new ConfigNotFoundError(
-    "No template found. Use 'miravo templates list' to find built-ins or pass 'miravo load --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 load:",
-    options: templates.map((t) => ({
-      value: t.path,
-      label: t.name,
-      hint: t.description ?? t.id,
-    })),
-    maxItems: 9,
-  });
-
-  if (isCancel(choice)) {
-    process.exit(0);
-  }
-
-  configLog.info("Tip: use --template <id> to skip this prompt next time.");
-
-  return choice as string;
-}

package/src/commands/logs.ts

@@ -1,173 +0,0 @@
-import type { WSMessage } from "@miravo/shared";
-import type { Command } from "commander";
-import { colors } from "consola/utils";
-import { isPidAlive, readEntry } from "../lib/daemon-registry.ts";
-import { parseNonNegativeInt } from "../lib/parse.ts";
-import { handleCommandError, writeOutput } from "../logger.ts";
-
-interface LogsOptions {
-  readonly tail?: number;
-  readonly channels?: string;
-}
-
-export function registerLogsCommand(program: Command): void {
-  program
-    .command("logs <name>")
-    .description("Stream domain events from a background simulation")
-    .option("--tail <n>", "Fetch last N events before streaming", parseNonNegativeInt)
-    .option(
-      "--channels <list>",
-      "Comma-separated channels: faults,lifecycle,instances,adapters,engine (default: all except tick)",
-    )
-    .addHelpText(
-      "after",
-      `
-Examples:
-  $ miravo logs my-sim                     Stream live events
-  $ miravo logs my-sim --tail 50           Show last 50 events first
-  $ miravo logs my-sim --channels faults   Only fault events`,
-    )
-    .action(async (name: string, options: LogsOptions) => {
-      try {
-        await logsAction(name, options);
-      } catch (error) {
-        handleCommandError(error);
-      }
-    });
-}
-
-async function logsAction(name: string, options: LogsOptions): Promise<void> {
-  const entry = await readEntry(name);
-  if (!entry) {
-    writeOutput(`Simulation "${name}" not found. Use 'miravo ps' to list running simulations.`);
-    process.exitCode = 1;
-    return;
-  }
-
-  if (!isPidAlive(entry.pid)) {
-    writeOutput(`Simulation "${name}" is not running.`);
-    process.exitCode = 1;
-    return;
-  }
-
-  const adminUrl = `http://${entry.adminHost}:${entry.adminPort}`;
-
-  // Fetch historical events if --tail is set
-  if (options.tail !== undefined && options.tail > 0) {
-    try {
-      const response = await fetch(`${adminUrl}/events?limit=${options.tail}`, {
-        signal: AbortSignal.timeout(5_000),
-      });
-      if (response.ok) {
-        const result = (await response.json()) as { events: readonly Record<string, unknown>[] };
-        for (const event of result.events) {
-          const formatted = formatLoggedEvent(event);
-          if (formatted) writeOutput(formatted);
-        }
-      }
-    } catch {
-      writeOutput("Warning: could not fetch historical events.");
-    }
-  }
-
-  // Connect WebSocket for live streaming
-  const wsUrl = `ws://${entry.adminHost}:${entry.adminPort}/ws`;
-
-  const selectedChannels = options.channels
-    ? options.channels.split(",").map((c) => c.trim())
-    : ["faults", "lifecycle", "instances", "engine", "adapters"];
-
-  const ws = new WebSocket(wsUrl);
-  let connected = false;
-  let userInitiatedClose = false;
-
-  const cleanup = (): void => {
-    userInitiatedClose = true;
-    ws.close();
-    process.exit(0);
-  };
-  process.once("SIGINT", cleanup);
-  process.once("SIGTERM", cleanup);
-
-  ws.onopen = () => {
-    connected = true;
-    ws.send(JSON.stringify({ type: "subscribe", channels: selectedChannels }));
-    writeOutput(
-      `${colors.dim("Connected to")} ${name} ${colors.dim(`(channels: ${selectedChannels.join(", ")})`)}`,
-    );
-    writeOutput(colors.dim("Waiting for events... (Ctrl+C to stop)"));
-  };
-
-  ws.onmessage = (event) => {
-    try {
-      const msg = JSON.parse(String(event.data)) as WSMessage;
-      const formatted = formatWSEvent(msg);
-      if (formatted) writeOutput(formatted);
-    } catch {
-      // Ignore parse errors
-    }
-  };
-
-  ws.onerror = () => {
-    if (!connected) {
-      writeOutput(`Failed to connect to simulation "${name}". Is it still running?`);
-      process.exit(1);
-    }
-    writeOutput(`Connection lost to simulation "${name}".`);
-  };
-
-  // Keep alive until WebSocket closes
-  await new Promise<void>((resolve) => {
-    ws.onclose = () => resolve();
-  });
-
-  if (!connected || !userInitiatedClose) {
-    process.exit(1);
-  }
-}
-
-/** Format a WebSocket message for terminal output. Returns null for tick/snapshot events. */
-function formatWSEvent(msg: WSMessage): string | null {
-  if (msg.type !== "runtime:event") return null;
-  const evt = msg.event;
-  switch (evt.kind) {
-    case "fault:triggered":
-      return `${colors.red("[fault:triggered]")} ${evt.instanceId} · ${evt.fault}`;
-    case "fault:cleared":
-      return `${colors.green("[fault:cleared]")} ${evt.instanceId} · ${evt.fault}`;
-    case "lifecycle:changed":
-      return `${colors.blue("[lifecycle:changed]")} ${evt.instanceId} · ${evt.from} → ${evt.to}`;
-    case "instance:created":
-      return `${colors.cyan("[instance:created]")} ${evt.id} · ${evt.assetType}`;
-    case "instance:removed":
-      return `${colors.yellow("[instance:removed]")} ${evt.id}`;
-    case "engine:state":
-      return `${colors.magenta("[engine:state]")} ${evt.from} → ${evt.to}`;
-    case "adapter:enabled":
-      return `${colors.cyan("[adapter:enabled]")} ${evt.name}`;
-    case "adapter:disabled":
-      return `${colors.yellow("[adapter:disabled]")} ${evt.name}`;
-    default:
-      return null;
-  }
-}
-
-function formatLoggedEvent(event: Record<string, unknown>): string | null {
-  const type = event["type"];
-  if (typeof type !== "string") return null;
-
-  switch (type) {
-    case "fault:triggered":
-      return `${colors.red("[fault:triggered]")} ${event["instanceId"]} · ${event["fault"]}`;
-    case "fault:cleared":
-      return `${colors.green("[fault:cleared]")} ${event["instanceId"]} · ${event["fault"]}`;
-    case "lifecycle:changed":
-      return `${colors.blue("[lifecycle:changed]")} ${event["instanceId"]} · ${event["from"]} → ${event["to"]}`;
-    case "instance:created":
-      return `${colors.cyan("[instance:created]")} ${event["instanceId"]} · ${event["assetType"]}`;
-    case "instance:removed":
-      return `${colors.yellow("[instance:removed]")} ${event["instanceId"]}`;
-    default:
-      return null;
-  }
-}