miravo 0.6.0 → 0.6.2

package/src/lib/le/le-auth.ts

@@ -1,89 +0,0 @@
-/**
- * LE auth and hostname resolution.
- *
- * Resolution order: CLI flag → environment variable → ~/.miravo/platforms/environments.json → fail.
- */
-
-import type { LEClientConfig } from "./le-client.ts";
-import { getDefaultEnvironment, getEnvironmentByLabel } from "./le-environments.ts";
-
-/**
- * Resolve a named environment from ~/.miravo/platforms/environments.json.
- * Returns undefined when no `--environment` flag was provided,
- * or throws when the label doesn't match any stored environment.
- */
-async function resolveNamedEnvironment(
-  environmentLabel: string | undefined,
-): Promise<
-  | { readonly hostname: string; readonly apiToken: string; readonly sourceHostname: string }
-  | undefined
-> {
-  if (!environmentLabel) return undefined;
-  const env = await getEnvironmentByLabel(environmentLabel);
-  if (!env) {
-    throw new Error(
-      `Environment "${environmentLabel}" not found. Check the label in ~/.miravo/platforms/environments.json or the console.`,
-    );
-  }
-  return env;
-}
-
-export async function resolveLeAuth(opts: {
-  environment?: string | undefined;
-  leHostname?: string | undefined;
-  leApiToken?: string | undefined;
-}): Promise<LEClientConfig> {
-  // 1. Named environment (--environment flag)
-  const named = await resolveNamedEnvironment(opts.environment);
-  if (named) {
-    return {
-      hostname: opts.leHostname || named.hostname,
-      apiToken: opts.leApiToken || named.apiToken,
-    };
-  }
-
-  // 2. CLI flags / env vars
-  const hostname = opts.leHostname || Bun.env["LITMUS_EDGE_HOSTNAME"];
-  const apiToken = opts.leApiToken || Bun.env["LITMUS_EDGE_API_TOKEN"];
-
-  if (hostname && apiToken) {
-    return { hostname, apiToken };
-  }
-
-  // 3. Default environment from ~/.miravo/platforms/environments.json
-  const defaultEnv = await getDefaultEnvironment();
-  if (defaultEnv) {
-    return {
-      hostname: hostname || defaultEnv.hostname,
-      apiToken: apiToken || defaultEnv.apiToken,
-    };
-  }
-
-  if (!hostname) {
-    throw new Error(
-      "Missing LE hostname. Provide --environment, --le-hostname, set LITMUS_EDGE_HOSTNAME, or configure an environment via the console.",
-    );
-  }
-  throw new Error(
-    "Missing LE API token. Provide --environment, --le-api-token, set LITMUS_EDGE_API_TOKEN, or configure an environment via the console.",
-  );
-}
-
-export async function resolveSourceHostname(opts: {
-  environment?: string | undefined;
-  sourceHostname?: string | undefined;
-}): Promise<string> {
-  const hostname = opts.sourceHostname || Bun.env["MIRAVO_SOURCE_HOSTNAME"];
-  if (hostname) return hostname;
-
-  // Named environment takes priority over default
-  const named = await resolveNamedEnvironment(opts.environment);
-  if (named) return named.sourceHostname;
-
-  const defaultEnv = await getDefaultEnvironment();
-  if (defaultEnv) return defaultEnv.sourceHostname;
-
-  throw new Error(
-    "Missing source hostname. Provide --environment, --source-hostname, set MIRAVO_SOURCE_HOSTNAME, or configure an environment via the console.",
-  );
-}

package/src/lib/le/le-cleanup.test.ts

@@ -1,168 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { buildCleanupPlan, executeCleanup } from "./le-cleanup.ts";
-import type { LEDevice, LEDeviceHub } from "./le-devicehub.ts";
-import type { LEDigitalTwins, LEModel } from "./le-digital-twins.ts";
-
-function createModel(id: string, name: string): LEModel {
-  return { ID: id, Name: name, Description: "", Version: 1 };
-}
-
-function createManagedDevice(name: string, modelName: string): LEDevice {
-  return {
-    ID: `device-${name}`,
-    Name: name,
-    DriverID: "driver-1",
-    Properties: [],
-    MetaData: [
-      { Name: "miravo_managed", Value: "true" },
-      { Name: "miravo_template", Value: "smart-factory" },
-      { Name: "miravo_instance", Value: "pump-001" },
-      { Name: "miravo_model", Value: modelName },
-      { Name: "miravo_protocol", Value: "opcua" },
-    ],
-    Description: "",
-  };
-}
-
-function createCleanupOptions(
-  overrides?: Partial<{
-    templateId: string;
-    scope: readonly ("devices" | "models" | "instances")[];
-    allManaged: boolean;
-  }>,
-): {
-  templateId: string;
-  targetHost: string;
-  scope: readonly ("devices" | "models" | "instances")[];
-  filters: { area?: string; line?: string; instance?: string };
-  allManaged: boolean;
-  dryRun: boolean;
-} {
-  return {
-    templateId: overrides?.templateId ?? "smart-factory",
-    targetHost: "le.example.local",
-    scope: overrides?.scope ?? ["models"],
-    filters: {},
-    allManaged: overrides?.allManaged ?? true,
-    dryRun: true,
-  };
-}
-
-function managedModelStaticAttrs(): { Key: string; Value: string }[] {
-  return [
-    { Key: "miravo_managed", Value: "true" },
-    { Key: "miravo_template", Value: "smart-factory" },
-    { Key: "miravo_model", Value: "ac-induction-motor" },
-  ];
-}
-
-describe("buildCleanupPlan model discovery", () => {
-  test("all-managed includes models with DT markers when devices are gone", async () => {
-    const models = [
-      createModel("model-1", "AC-INDUCTION-MOTOR"),
-      createModel("model-2", "AC-INDUCTION-MOTOR"),
-      createModel("model-3", "UNRELATED-MODEL"),
-    ];
-
-    const hub: LEDeviceHub = {
-      async listDevices() {
-        return [];
-      },
-    } as unknown as LEDeviceHub;
-
-    const dt: LEDigitalTwins = {
-      async listModels() {
-        return models;
-      },
-      async listStaticAttributes(opts: { modelId?: string; instanceId?: string }) {
-        const mid = opts.modelId;
-        if (mid === "model-1" || mid === "model-2") return managedModelStaticAttrs();
-        return [];
-      },
-    } as unknown as LEDigitalTwins;
-
-    const result = await buildCleanupPlan(hub, dt, createCleanupOptions({ allManaged: true }));
-
-    expect(result.plan.entries).toHaveLength(2);
-    expect(result.plan.entries.map((entry) => entry.resourceId).sort()).toEqual([
-      "model-1",
-      "model-2",
-    ]);
-  });
-
-  test("device-marker fallback includes all duplicate DT model IDs for scoped cleanup", async () => {
-    const models = [
-      createModel("model-1", "AC-INDUCTION-MOTOR"),
-      createModel("model-2", "AC-INDUCTION-MOTOR"),
-    ];
-
-    const hub: LEDeviceHub = {
-      async listDevices() {
-        return [createManagedDevice("pump-001", "ac-induction-motor")];
-      },
-    } as unknown as LEDeviceHub;
-
-    const dt: LEDigitalTwins = {
-      async listModels() {
-        return models;
-      },
-      async listStaticAttributes() {
-        return [];
-      },
-    } as unknown as LEDigitalTwins;
-
-    const result = await buildCleanupPlan(
-      hub,
-      dt,
-      createCleanupOptions({ allManaged: false, templateId: "smart-factory", scope: ["models"] }),
-    );
-
-    expect(result.plan.entries).toHaveLength(2);
-    expect(result.plan.entries.map((entry) => entry.resourceId).sort()).toEqual([
-      "model-1",
-      "model-2",
-    ]);
-  });
-});
-
-describe("executeCleanup duplicate-safe deletion", () => {
-  test("deletes duplicate model names by resource ID", async () => {
-    const models = [
-      createModel("model-1", "AC-INDUCTION-MOTOR"),
-      createModel("model-2", "AC-INDUCTION-MOTOR"),
-    ];
-
-    const hub: LEDeviceHub = {
-      async listDevices() {
-        return [];
-      },
-    } as unknown as LEDeviceHub;
-
-    const deletedModelIds: string[] = [];
-    const dt: LEDigitalTwins = {
-      async listModels() {
-        return models;
-      },
-      async listStaticAttributes(opts: { modelId?: string; instanceId?: string }) {
-        const mid = opts.modelId;
-        if (mid === "model-1" || mid === "model-2") return managedModelStaticAttrs();
-        return [];
-      },
-      async deleteModel(id: string) {
-        deletedModelIds.push(id);
-      },
-    } as unknown as LEDigitalTwins;
-
-    const planResult = await buildCleanupPlan(hub, dt, createCleanupOptions({ allManaged: true }));
-    const result = await executeCleanup(
-      hub,
-      dt,
-      planResult,
-      createCleanupOptions({ allManaged: true }),
-    );
-
-    expect(result.failed).toBe(0);
-    expect(result.deleted).toBe(2);
-    expect(deletedModelIds.sort()).toEqual(["model-1", "model-2"]);
-  });
-});

package/src/lib/le/le-cleanup.ts

@@ -1,399 +0,0 @@
-/**
- * LE Cleanup reconciler.
- *
- * Discovers Miravo-managed resources and deletes them in
- * reverse dependency order: instances → models → devices.
- */
-
-import type { ResourceProgress } from "./le-apply.ts";
-import { formatThrownError, pMap } from "./le-concurrency.ts";
-import type { LEDevice, LEDeviceHub } from "./le-devicehub.ts";
-import type { LEDigitalTwins, LEInstance, LEModel } from "./le-digital-twins.ts";
-import { type DeviceMarkerData, parseDeviceMarkers, parseDTMarkers } from "./le-markers.ts";
-import type { ApplyPlan, ApplyScope, PlanEntry } from "./le-plan.ts";
-
-/** Max concurrent LE API calls during cleanup discovery. Tuned for edge devices. */
-const LE_CLEANUP_CONCURRENCY = 5;
-
-interface CleanupOptions {
-  readonly templateId: string;
-  readonly targetHost: string;
-  readonly scope: readonly ApplyScope[];
-  readonly filters: {
-    readonly area?: string | undefined;
-    readonly line?: string | undefined;
-    readonly instance?: string | undefined;
-  };
-  readonly allManaged: boolean;
-  readonly dryRun: boolean;
-  readonly onProgress?: ((msg: string) => void) | undefined;
-  readonly onResourceComplete?: ((progress: ResourceProgress) => void) | undefined;
-  readonly signal?: AbortSignal | undefined;
-}
-
-interface CleanupResult {
-  readonly plan: ApplyPlan;
-  readonly deleted: number;
-  readonly failed: number;
-  readonly failedEntries: readonly { entry: PlanEntry; error: string }[];
-  readonly error?: string | undefined;
-}
-
-interface CleanupSnapshot {
-  readonly deviceById: Map<string, LEDevice>;
-  readonly modelById: Map<string, LEModel>;
-  readonly instanceById: Map<string, LEInstance>;
-  readonly deviceByName: Map<string, LEDevice[]>;
-  readonly modelByName: Map<string, LEModel[]>;
-  readonly instanceByName: Map<string, LEInstance[]>;
-}
-
-interface CleanupPlanResult {
-  readonly plan: ApplyPlan;
-  readonly snapshot: CleanupSnapshot;
-}
-
-function indexByName<T extends { Name: string }>(items: readonly T[]): Map<string, T[]> {
-  const byName = new Map<string, T[]>();
-  for (const item of items) {
-    const existing = byName.get(item.Name);
-    if (existing) {
-      existing.push(item);
-    } else {
-      byName.set(item.Name, [item]);
-    }
-  }
-  return byName;
-}
-
-/** Build a cleanup plan by discovering managed resources. */
-export async function buildCleanupPlan(
-  hub: LEDeviceHub,
-  dt: LEDigitalTwins,
-  opts: CleanupOptions,
-): Promise<CleanupPlanResult> {
-  const scope = opts.scope;
-
-  const needModels = scope.includes("models");
-  const needDevices = scope.includes("devices");
-  const needInstances = scope.includes("instances");
-  // Models are fetched when in scope or when instances are in scope (for the ownership cascade)
-  const fetchModels = needModels || needInstances;
-  // Devices are fetched when in scope or when models are in scope (device markers are the fallback for model discovery)
-  const fetchDevices = needDevices || fetchModels;
-
-  // Fetch all lists in parallel
-  const [models, devices, instances] = await Promise.all([
-    fetchModels ? dt.listModels() : ([] as readonly LEModel[]),
-    fetchDevices ? hub.listDevices() : ([] as readonly LEDevice[]),
-    needInstances
-      ? dt.listInstances().catch((): readonly LEInstance[] => {
-          opts.onProgress?.(
-            "⚠ Warning: LE ListInstances failed — skipping instance cleanup scope.",
-          );
-          return [];
-        })
-      : ([] as readonly LEInstance[]),
-  ]);
-
-  // --- Discover managed devices early (needed as model fallback) ---
-  // Devices store markers in DeviceHub metadata which is reliable — unlike
-  // DT static attributes which may fail during apply.
-  const managedDeviceMarkers: { device: LEDevice; markers: DeviceMarkerData }[] = [];
-  if (fetchDevices) {
-    for (const device of devices) {
-      const markers = parseDeviceMarkers(device.MetaData);
-      if (!markers) continue;
-      if (!opts.allManaged && markers.templateId !== opts.templateId) continue;
-      managedDeviceMarkers.push({ device, markers });
-    }
-  }
-
-  // --- Models ---
-  // managedModelIds is always populated (even when models not in scope) because
-  // the instance ownership cascade needs it.
-  const managedModelIds = new Set<string>();
-  const modelEntries: PlanEntry[] = [];
-  const modelByName = indexByName(models);
-
-  function includeManagedModel(model: LEModel): void {
-    if (managedModelIds.has(model.ID)) return;
-    managedModelIds.add(model.ID);
-    if (!needModels) return;
-    modelEntries.push({
-      action: "delete",
-      resourceType: "model",
-      name: model.Name,
-      resourceId: model.ID,
-      detail: `(id: ${model.ID})`,
-    });
-  }
-
-  // Discover model + instance markers in a single concurrent pass (shared pool).
-  // Both hit the same DT ListStaticAttributes endpoint, so a shared concurrency
-  // limit avoids overloading the edge device.
-  const modelMarkersById = new Map<string, ReturnType<typeof parseDTMarkers>>();
-  const instanceMarkersById = new Map<string, ReturnType<typeof parseDTMarkers>>();
-
-  type MarkerQuery =
-    | { readonly kind: "model"; readonly entity: LEModel }
-    | { readonly kind: "instance"; readonly entity: LEInstance };
-
-  const markerQueries: MarkerQuery[] = [
-    ...models.map((m): MarkerQuery => ({ kind: "model", entity: m })),
-    ...(needInstances ? instances.map((i): MarkerQuery => ({ kind: "instance", entity: i })) : []),
-  ];
-
-  await pMap(
-    markerQueries,
-    async (q) => {
-      const id = q.entity.ID;
-      const target = q.kind === "model" ? modelMarkersById : instanceMarkersById;
-      try {
-        const attrs = await dt.listStaticAttributes(
-          q.kind === "model" ? { modelId: id } : { instanceId: id },
-        );
-        target.set(id, parseDTMarkers(attrs));
-      } catch {
-        target.set(id, undefined);
-      }
-    },
-    { concurrency: LE_CLEANUP_CONCURRENCY },
-  );
-
-  // --- Process model markers ---
-
-  for (const model of models) {
-    const markers = modelMarkersById.get(model.ID);
-    if (!markers) continue;
-    if (!opts.allManaged && markers.templateId !== opts.templateId) continue;
-    includeManagedModel(model);
-  }
-
-  // Device-marker fallback: device metadata stores miravo_model (raw catalog name);
-  // DT model Name is the uppercased version. Include all matching model IDs to handle
-  // duplicates created by re-import.
-  for (const { markers } of managedDeviceMarkers) {
-    for (const model of modelByName.get(markers.modelName.toUpperCase()) ?? []) {
-      includeManagedModel(model);
-    }
-  }
-
-  // --- Process instance markers ---
-  // Instances with miravo_managed="true" are included directly.
-  // Instances without markers (or with miravo_managed="false") are included
-  // if their parent model is managed — model ownership cascades to all instances.
-  const instanceEntries: PlanEntry[] = [];
-  if (needInstances) {
-    for (const inst of instances) {
-      const markers = instanceMarkersById.get(inst.ID);
-      let include: boolean;
-      if (markers) {
-        include = opts.allManaged || markers.templateId === opts.templateId;
-      } else {
-        // No instance markers — include if the parent model is managed
-        include = managedModelIds.has(inst.ModelID);
-      }
-      if (!include) continue;
-      if (opts.filters.instance) {
-        if (!markers) {
-          opts.onProgress?.(
-            `⚠ Warning: instance ${inst.Name} has no markers — cannot match --instance filter, skipping.`,
-          );
-          continue;
-        }
-        if (markers.instanceId !== opts.filters.instance) continue;
-      }
-      instanceEntries.push({
-        action: "delete",
-        resourceType: "instance",
-        name: inst.Name,
-        resourceId: inst.ID,
-        detail: `(id: ${inst.ID})`,
-      });
-    }
-  }
-
-  // Deletion order: instances → models → devices
-  const entries: PlanEntry[] = [...instanceEntries, ...modelEntries];
-
-  if (needDevices) {
-    for (const { device, markers } of managedDeviceMarkers) {
-      if (opts.filters.instance && markers.instanceId !== opts.filters.instance) continue;
-      entries.push({
-        action: "delete",
-        resourceType: "device",
-        name: device.Name,
-        resourceId: device.ID,
-        detail: `(id: ${device.ID})`,
-      });
-    }
-  }
-
-  const plan: ApplyPlan = {
-    sourceMode: opts.allManaged ? "managed" : "static",
-    targetHost: opts.targetHost,
-    sourceHostname: undefined,
-    scope: [...opts.scope],
-    filters: opts.filters,
-    entries,
-  };
-
-  return {
-    plan,
-    snapshot: {
-      deviceById: new Map(devices.map((d) => [d.ID, d])),
-      modelById: new Map(models.map((m) => [m.ID, m])),
-      instanceById: new Map(instances.map((i) => [i.ID, i])),
-      deviceByName: indexByName(devices),
-      modelByName: indexByName(models),
-      instanceByName: indexByName(instances),
-    },
-  };
-}
-
-/** Execute cleanup using the snapshot from plan building (no re-fetch). */
-export async function executeCleanup(
-  hub: LEDeviceHub,
-  dt: LEDigitalTwins,
-  { plan, snapshot }: CleanupPlanResult,
-  opts: CleanupOptions,
-): Promise<CleanupResult> {
-  const log = opts.onProgress ?? (() => {});
-  const onResource = opts.onResourceComplete;
-  let deleted = 0;
-
-  // Pre-compute per-phase totals for progress reporting
-  const phaseTotals = new Map<string, number>();
-  const phaseCounters = new Map<string, number>();
-  for (const entry of plan.entries) {
-    phaseTotals.set(entry.resourceType, (phaseTotals.get(entry.resourceType) ?? 0) + 1);
-  }
-
-  function emitProgress(
-    phase: string,
-    name: string,
-    status: "success" | "failed",
-    error?: string,
-    count?: number,
-  ): void {
-    const idx = (phaseCounters.get(phase) ?? 0) + 1;
-    phaseCounters.set(phase, idx);
-    onResource?.({
-      phase,
-      resourceType: phase,
-      name,
-      action: "delete",
-      status,
-      error,
-      index: idx,
-      of: phaseTotals.get(phase) ?? 0,
-      count,
-    });
-  }
-
-  const { deviceById, modelById, instanceById, deviceByName, modelByName, instanceByName } =
-    snapshot;
-
-  function resolveInstance(entry: PlanEntry): LEInstance | undefined {
-    if (entry.resourceId) return instanceById.get(entry.resourceId);
-    const matches = instanceByName.get(entry.name) ?? [];
-    return matches[0];
-  }
-
-  function resolveModel(entry: PlanEntry): LEModel | undefined {
-    if (entry.resourceId) return modelById.get(entry.resourceId);
-    const matches = modelByName.get(entry.name) ?? [];
-    return matches[0];
-  }
-
-  function resolveDevice(entry: PlanEntry): LEDevice | undefined {
-    if (entry.resourceId) return deviceById.get(entry.resourceId);
-    const matches = deviceByName.get(entry.name) ?? [];
-    return matches[0];
-  }
-
-  // Group entries by resource type, then process in dependency order
-  const CLEANUP_ORDER = ["instance", "model", "device"] as const;
-  type CleanupPhase = (typeof CLEANUP_ORDER)[number];
-  const groups = new Map<CleanupPhase, PlanEntry[]>();
-  for (const entry of plan.entries) {
-    if (entry.resourceType === "param-sync") continue;
-    const phase = entry.resourceType as CleanupPhase;
-    const list = groups.get(phase) ?? [];
-    list.push(entry);
-    groups.set(phase, list);
-  }
-
-  const failedEntries: { entry: PlanEntry; error: string }[] = [];
-
-  async function deleteEntry(entry: PlanEntry): Promise<void> {
-    switch (entry.resourceType) {
-      case "instance": {
-        const inst = resolveInstance(entry);
-        if (!inst) {
-          log(`  SKIP instance ${entry.name} (not found)`);
-          return;
-        }
-        await dt.deleteInstance(inst.ID);
-        log(`✓ DELETE DT instance ${entry.name}`);
-        deleted++;
-        emitProgress("instance", entry.name, "success");
-        break;
-      }
-      case "model": {
-        const model = resolveModel(entry);
-        if (!model) {
-          log(`  SKIP model ${entry.name} (not found)`);
-          return;
-        }
-        await dt.deleteModel(model.ID);
-        log(`✓ DELETE DT model ${entry.name}`);
-        deleted++;
-        emitProgress("model", entry.name, "success");
-        break;
-      }
-      case "device": {
-        const device = resolveDevice(entry);
-        if (!device) {
-          log(`  SKIP device ${entry.name} (not found)`);
-          return;
-        }
-        await hub.deleteDevices([device.ID]);
-        log(`✓ DELETE device ${entry.name}`);
-        deleted++;
-        emitProgress("device", entry.name, "success");
-        break;
-      }
-    }
-  }
-
-  for (const phase of CLEANUP_ORDER) {
-    const entries = groups.get(phase);
-    if (!entries?.length) continue;
-    if (opts.signal?.aborted) break;
-
-    await pMap(
-      entries,
-      async (entry) => {
-        try {
-          await deleteEntry(entry);
-        } catch (err) {
-          const msg = formatThrownError(err);
-          log(`✗ DELETE ${entry.resourceType} ${entry.name} — ${msg}`);
-          emitProgress(entry.resourceType, entry.name, "failed", msg);
-          failedEntries.push({ entry, error: msg });
-        }
-      },
-      { concurrency: LE_CLEANUP_CONCURRENCY, ...(opts.signal ? { signal: opts.signal } : {}) },
-    );
-  }
-
-  return {
-    plan,
-    deleted,
-    failed: failedEntries.length,
-    failedEntries,
-    error: failedEntries[0]?.error,
-  };
-}