miravo 0.6.0 → 0.6.2

package/src/lib/auth-store.ts

@@ -1,87 +0,0 @@
-/**
- * Credential storage — persists admin password at ~/.miravo/auth.json.
- *
- * Password priority: MIRAVO_ADMIN_PASSWORD env > ~/.miravo/auth.json > default "admin".
- */
-
-import { mkdir } from "node:fs/promises";
-import { resolveMiravoHome } from "@miravo/core";
-import type { PersistedCredential } from "@miravo/shared";
-import { PersistedCredentialSchema } from "@miravo/shared";
-
-// ---------------------------------------------------------------------------
-// Paths
-// ---------------------------------------------------------------------------
-
-function authFilePath(): string {
-  return `${resolveMiravoHome()}/auth.json`;
-}
-
-// ---------------------------------------------------------------------------
-// Read / Write
-// ---------------------------------------------------------------------------
-
-/** Load persisted credential from ~/.miravo/auth.json. Returns null if missing or invalid. */
-export async function loadCredential(): Promise<PersistedCredential | null> {
-  const file = Bun.file(authFilePath());
-  if (!(await file.exists())) return null;
-  try {
-    const raw: unknown = await file.json();
-    const result = PersistedCredentialSchema.safeParse(raw);
-    return result.success ? result.data : null;
-  } catch {
-    return null;
-  }
-}
-
-/** Persist credential to ~/.miravo/auth.json with restricted permissions. */
-export async function saveCredential(username: string, passwordHash: string): Promise<void> {
-  const filePath = authFilePath();
-  const dir = resolveMiravoHome();
-  await mkdir(dir, { recursive: true });
-  const data: PersistedCredential = { username, passwordHash };
-  await Bun.write(filePath, JSON.stringify(data, null, 2), { mode: 0o600 });
-}
-
-// ---------------------------------------------------------------------------
-// Password resolution
-// ---------------------------------------------------------------------------
-
-interface ResolvedPassword {
-  /** Argon2id hash of the effective admin password. */
-  readonly passwordHash: string;
-  /** True when the effective password is the literal default "admin". */
-  readonly isDefault: boolean;
-}
-
-/**
- * Resolve the admin password with priority:
- *   1. MIRAVO_ADMIN_PASSWORD env var (plaintext → hashed)
- *   2. ~/.miravo/auth.json (already hashed)
- *   3. Default "admin" (plaintext → hashed)
- */
-export async function resolveAdminPassword(): Promise<ResolvedPassword> {
-  // 1. Environment override
-  const envPassword = Bun.env["MIRAVO_ADMIN_PASSWORD"];
-  if (envPassword && envPassword.trim().length > 0) {
-    return {
-      passwordHash: await Bun.password.hash(envPassword),
-      isDefault: envPassword === "admin",
-    };
-  }
-
-  // 2. Persisted credential file
-  const credential = await loadCredential();
-  if (credential) {
-    return {
-      passwordHash: credential.passwordHash,
-      isDefault: false, // File exists → user changed password at some point
-    };
-  }
-
-  // 3. Default
-  return {
-    passwordHash: await Bun.password.hash("admin"),
-    isDefault: true,
-  };
-}

package/src/lib/daemon-registry.test.ts

@@ -1,429 +0,0 @@
-import { afterEach, describe, expect, test } from "bun:test";
-import { mkdir, mkdtemp, rm } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import type { DaemonRegistryEntry } from "./daemon-registry.ts";
-import {
-  acquireNameLock,
-  checkNameConflict,
-  checkPortConflicts,
-  displayHost,
-  isPidAlive,
-  listEntries,
-  probeEntryIdentity,
-  readEntry,
-  removeEntry,
-  sweepStaleEntries,
-  writeEntry,
-} from "./daemon-registry.ts";
-
-/** Override MIRAVO_HOME to isolate tests from real daemon state. */
-let testHome: string;
-const serverHandles: Array<{ stop: () => void }> = [];
-
-async function setupTestHome(): Promise<void> {
-  testHome = await mkdtemp(join(tmpdir(), "miravo-daemon-test-"));
-  Bun.env["MIRAVO_HOME"] = testHome;
-}
-
-afterEach(async () => {
-  for (const handle of serverHandles) {
-    handle.stop();
-  }
-  serverHandles.length = 0;
-  delete Bun.env["MIRAVO_HOME"];
-  if (testHome) {
-    await rm(testHome, { recursive: true, force: true });
-  }
-});
-
-function makeEntry(overrides: Partial<DaemonRegistryEntry> = {}): DaemonRegistryEntry {
-  return {
-    name: "test-sim",
-    pid: 99999,
-    adminPort: 8080,
-    adminHost: "127.0.0.1",
-    adapters: {
-      mqtt: { port: 1883, host: "0.0.0.0" },
-    },
-    templatePath: "/tmp/test.miravo.yaml",
-    startedAt: "2026-03-17T10:00:00Z",
-    seed: 42,
-    runId: "test-run-id",
-    ...overrides,
-  };
-}
-
-describe("daemon-registry", () => {
-  describe("writeEntry + readEntry", () => {
-    test("round-trip writes and reads an entry", async () => {
-      await setupTestHome();
-      const entry = makeEntry();
-      await writeEntry(entry);
-      const read = await readEntry("test-sim");
-      expect(read).toEqual(entry);
-    });
-
-    test("overwrites existing entry", async () => {
-      await setupTestHome();
-      const entry1 = makeEntry({ pid: 111 });
-      const entry2 = makeEntry({ pid: 222 });
-      await writeEntry(entry1);
-      await writeEntry(entry2);
-      const read = await readEntry("test-sim");
-      expect(read?.pid).toBe(222);
-    });
-  });
-
-  describe("readEntry", () => {
-    test("returns null for missing file", async () => {
-      await setupTestHome();
-      const result = await readEntry("nonexistent");
-      expect(result).toBeNull();
-    });
-
-    test("returns null for invalid JSON", async () => {
-      await setupTestHome();
-      const dir = join(testHome, "daemon");
-      const { mkdir } = await import("node:fs/promises");
-      await mkdir(dir, { recursive: true });
-      await Bun.write(join(dir, "bad.json"), "not json");
-      const result = await readEntry("bad");
-      expect(result).toBeNull();
-    });
-
-    test("returns null for valid JSON that fails schema", async () => {
-      await setupTestHome();
-      const dir = join(testHome, "daemon");
-      const { mkdir } = await import("node:fs/promises");
-      await mkdir(dir, { recursive: true });
-      await Bun.write(join(dir, "partial.json"), JSON.stringify({ name: "partial" }));
-      const result = await readEntry("partial");
-      expect(result).toBeNull();
-    });
-  });
-
-  describe("removeEntry", () => {
-    test("removes an existing entry", async () => {
-      await setupTestHome();
-      await writeEntry(makeEntry());
-      await removeEntry("test-sim");
-      const result = await readEntry("test-sim");
-      expect(result).toBeNull();
-    });
-
-    test("does not throw for missing entry", async () => {
-      await setupTestHome();
-      await expect(removeEntry("nonexistent")).resolves.toBeUndefined();
-    });
-  });
-
-  describe("listEntries", () => {
-    test("returns empty array when daemon dir does not exist", async () => {
-      await setupTestHome();
-      const entries = await listEntries();
-      expect(entries).toEqual([]);
-    });
-
-    test("returns all valid entries", async () => {
-      await setupTestHome();
-      await writeEntry(makeEntry({ name: "sim-a" }));
-      await writeEntry(makeEntry({ name: "sim-b" }));
-      const entries = await listEntries();
-      expect(entries).toHaveLength(2);
-      const names = entries.map((e) => e.name).sort();
-      expect(names).toEqual(["sim-a", "sim-b"]);
-    });
-
-    test("skips invalid files", async () => {
-      await setupTestHome();
-      await writeEntry(makeEntry({ name: "valid" }));
-      const dir = join(testHome, "daemon");
-      await Bun.write(join(dir, "invalid.json"), "broken");
-      const entries = await listEntries();
-      expect(entries).toHaveLength(1);
-      expect(entries[0]?.name).toBe("valid");
-    });
-
-    test("skips .tmp files", async () => {
-      await setupTestHome();
-      await writeEntry(makeEntry({ name: "valid" }));
-      const dir = join(testHome, "daemon");
-      await Bun.write(join(dir, "leftover.json.tmp"), JSON.stringify(makeEntry({ name: "tmp" })));
-      const entries = await listEntries();
-      expect(entries).toHaveLength(1);
-    });
-  });
-
-  describe("isPidAlive", () => {
-    test("returns true for own PID", () => {
-      expect(isPidAlive(process.pid)).toBe(true);
-    });
-
-    test("returns false for impossible PID", () => {
-      // PID 2^30 is extremely unlikely to exist
-      expect(isPidAlive(1_073_741_824)).toBe(false);
-    });
-  });
-
-  describe("sweepStaleEntries", () => {
-    test("removes entries with dead PIDs", async () => {
-      await setupTestHome();
-      // Use impossible PIDs so they're guaranteed dead
-      await writeEntry(makeEntry({ name: "dead-sim-a", pid: 1_073_741_824 }));
-      await writeEntry(makeEntry({ name: "dead-sim-b", pid: 1_073_741_825 }));
-
-      await sweepStaleEntries();
-
-      const entries = await listEntries();
-      expect(entries).toHaveLength(0);
-    });
-
-    test("keeps entries whose /readyz reports the same runId with 503", async () => {
-      await setupTestHome();
-      const server = Bun.serve({
-        hostname: "127.0.0.1",
-        port: 0,
-        fetch() {
-          return Response.json(
-            { status: "degraded", reason: "mqtt disconnected", runId: "test-run-id" },
-            { status: 503 },
-          );
-        },
-      });
-      serverHandles.push(server);
-      const port = server.port;
-      if (port === undefined) {
-        throw new Error("Failed to allocate test port.");
-      }
-
-      await writeEntry(
-        makeEntry({
-          name: "paused-sim",
-          pid: process.pid,
-          adminPort: port,
-          runId: "test-run-id",
-        }),
-      );
-
-      await sweepStaleEntries();
-
-      expect(await readEntry("paused-sim")).not.toBeNull();
-    });
-  });
-
-  describe("probeEntryIdentity", () => {
-    test("treats non-ready responses with a matching runId as verified", async () => {
-      const server = Bun.serve({
-        hostname: "127.0.0.1",
-        port: 0,
-        fetch() {
-          return Response.json({ status: "paused", runId: "test-run-id" }, { status: 503 });
-        },
-      });
-      serverHandles.push(server);
-      const port = server.port;
-      if (port === undefined) {
-        throw new Error("Failed to allocate test port.");
-      }
-
-      const result = await probeEntryIdentity(
-        makeEntry({
-          pid: process.pid,
-          adminPort: port,
-          runId: "test-run-id",
-        }),
-      );
-
-      expect(result).toEqual({ status: "verified", ready: false });
-    });
-
-    test("fails closed on malformed /readyz bodies", async () => {
-      const server = Bun.serve({
-        hostname: "127.0.0.1",
-        port: 0,
-        fetch() {
-          return new Response("<html>not json</html>", {
-            status: 200,
-            headers: { "content-type": "text/html" },
-          });
-        },
-      });
-      serverHandles.push(server);
-      const port = server.port;
-      if (port === undefined) {
-        throw new Error("Failed to allocate test port.");
-      }
-
-      const result = await probeEntryIdentity(
-        makeEntry({
-          pid: process.pid,
-          adminPort: port,
-          runId: "test-run-id",
-        }),
-      );
-
-      expect(result).toEqual({ status: "mismatch", ready: false });
-    });
-  });
-
-  describe("checkPortConflicts", () => {
-    test("detects admin port conflict", async () => {
-      await setupTestHome();
-      await writeEntry(makeEntry({ name: "existing", pid: process.pid, adminPort: 8080 }));
-
-      const ports = new Map([["admin", 8080]]);
-      const conflicts = await checkPortConflicts(ports);
-      expect(conflicts).toHaveLength(1);
-      expect(conflicts[0]).toContain("8080");
-      expect(conflicts[0]).toContain("existing");
-    });
-
-    test("detects adapter port conflict", async () => {
-      await setupTestHome();
-      await writeEntry(
-        makeEntry({
-          name: "existing",
-          pid: process.pid,
-          adapters: { mqtt: { port: 1883, host: "0.0.0.0" } },
-        }),
-      );
-
-      const ports = new Map([["mqtt", 1883]]);
-      const conflicts = await checkPortConflicts(ports);
-      expect(conflicts.length).toBeGreaterThan(0);
-      expect(conflicts[0]).toContain("1883");
-    });
-
-    test("excludes named entry from conflict check", async () => {
-      await setupTestHome();
-      await writeEntry(makeEntry({ name: "self", pid: process.pid, adminPort: 8080 }));
-
-      const ports = new Map([["admin", 8080]]);
-      const conflicts = await checkPortConflicts(ports, "self");
-      expect(conflicts).toHaveLength(0);
-    });
-
-    test("ignores entries with dead PIDs", async () => {
-      await setupTestHome();
-      await writeEntry(makeEntry({ name: "dead", pid: 1_073_741_824, adminPort: 8080 }));
-
-      const ports = new Map([["admin", 8080]]);
-      const conflicts = await checkPortConflicts(ports);
-      expect(conflicts).toHaveLength(0);
-    });
-
-    test("returns empty array when no conflicts", async () => {
-      await setupTestHome();
-      await writeEntry(makeEntry({ name: "existing", pid: process.pid, adminPort: 9090 }));
-
-      const ports = new Map([["admin", 8080]]);
-      const conflicts = await checkPortConflicts(ports);
-      expect(conflicts).toHaveLength(0);
-    });
-  });
-
-  describe("checkNameConflict", () => {
-    test("returns null when no entry exists", async () => {
-      await setupTestHome();
-      const result = await checkNameConflict("nonexistent");
-      expect(result).toBeNull();
-    });
-
-    test("removes entry when PID is dead", async () => {
-      await setupTestHome();
-      await writeEntry(makeEntry({ name: "stale", pid: 1_073_741_824 }));
-      const result = await checkNameConflict("stale");
-      expect(result).toBeNull();
-      // Verify file was cleaned up
-      const entry = await readEntry("stale");
-      expect(entry).toBeNull();
-    });
-
-    test("keeps the entry when the daemon is alive but not ready", async () => {
-      await setupTestHome();
-      const server = Bun.serve({
-        hostname: "127.0.0.1",
-        port: 0,
-        fetch() {
-          return Response.json({ status: "paused", runId: "test-run-id" }, { status: 503 });
-        },
-      });
-      serverHandles.push(server);
-      const port = server.port;
-      if (port === undefined) {
-        throw new Error("Failed to allocate test port.");
-      }
-
-      await writeEntry(
-        makeEntry({
-          name: "paused-sim",
-          pid: process.pid,
-          adminPort: port,
-          runId: "test-run-id",
-        }),
-      );
-
-      const result = await checkNameConflict("paused-sim");
-
-      expect(result?.name).toBe("paused-sim");
-      expect(await readEntry("paused-sim")).not.toBeNull();
-    });
-  });
-
-  describe("acquireNameLock", () => {
-    test("acquires lock when none exists", async () => {
-      await setupTestHome();
-      const release = await acquireNameLock("test-sim");
-      await release();
-    });
-
-    test("throws when lock is held by a live process", async () => {
-      await setupTestHome();
-      const dir = join(testHome, "daemon");
-      await mkdir(dir, { recursive: true });
-      await Bun.write(join(dir, "test-sim.lock"), String(process.pid));
-
-      await expect(acquireNameLock("test-sim")).rejects.toThrow("already starting");
-
-      // Clean up the manually created lock so afterEach can remove the dir
-      await Bun.file(join(dir, "test-sim.lock"))
-        .exists()
-        .then(async (exists) => {
-          if (exists) {
-            const { unlink } = await import("node:fs/promises");
-            await unlink(join(dir, "test-sim.lock")).catch(() => {});
-          }
-        });
-    });
-
-    test("clears stale lock from a dead process and succeeds", async () => {
-      await setupTestHome();
-      const dir = join(testHome, "daemon");
-      await mkdir(dir, { recursive: true });
-      // Write a lock with an impossible PID — guaranteed to be dead
-      await Bun.write(join(dir, "test-sim.lock"), "1073741824");
-
-      const release = await acquireNameLock("test-sim");
-      await release();
-    });
-  });
-
-  describe("displayHost", () => {
-    test("maps 0.0.0.0 to 127.0.0.1", () => {
-      expect(displayHost("0.0.0.0")).toBe("127.0.0.1");
-    });
-
-    test("maps :: to 127.0.0.1", () => {
-      expect(displayHost("::")).toBe("127.0.0.1");
-    });
-
-    test("passes through 127.0.0.1", () => {
-      expect(displayHost("127.0.0.1")).toBe("127.0.0.1");
-    });
-
-    test("passes through custom host", () => {
-      expect(displayHost("192.168.1.100")).toBe("192.168.1.100");
-    });
-  });
-});