@celilo/cli 2.0.0 → 2.1.0

package/src/services/control-plane-bootstrap.test.ts

@@ -0,0 +1,177 @@
+/**
+ * The control-plane bootstrap, which replaced celilo-mgmt's `on_install`
+ * (celilo#1225).
+ *
+ * Every dependency is injected, so these run against a real database and no
+ * host: no resolver file is read, no ssh-keygen runs, no bus is opened. That is
+ * the property the hook could not have. Its equivalents shelled out to the CLI,
+ * so the only way to exercise them was to have a celilo on PATH — which is also
+ * why the jail broke them and no unit test noticed.
+ */
+
+import { afterEach, beforeEach, describe, expect, test } from 'bun:test';
+import { mkdtempSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { eq } from 'drizzle-orm';
+import type { DbClient } from '../db/client';
+import { systemConfig } from '../db/schema';
+import { setupTestDatabaseAt } from '../test-utils/database';
+import {
+  type ControlPlaneBootstrapOptions,
+  bootstrapControlPlane,
+} from './control-plane-bootstrap';
+import type { FleetFinding } from './fleet-checks';
+
+const DNS = { primary: '9.9.9.9', fallback: '8.8.4.4' };
+const PUBLIC_KEY = 'ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAI test celilo-fleet';
+
+function dispatcher(status: FleetFinding['status']): FleetFinding {
+  return {
+    id: 'dispatcher',
+    title: 'Event dispatcher',
+    status,
+    summary: `dispatcher ${status}`,
+    detail: [],
+    remediation: status === 'ok' ? null : 'start the dispatcher',
+    autoFixable: false,
+  };
+}
+
+function configValue(db: DbClient, key: string): string | undefined {
+  return db.select().from(systemConfig).where(eq(systemConfig.key, key)).get()?.value ?? undefined;
+}
+
+describe('bootstrapControlPlane', () => {
+  let dir: string;
+  let db: DbClient;
+  /** Every sleep the poll performed, so waiting is asserted rather than timed. */
+  let sleeps: number[];
+
+  beforeEach(async () => {
+    dir = mkdtempSync(join(tmpdir(), 'cpb-'));
+    const dbPath = join(dir, 'celilo.db');
+    process.env.CELILO_DB_PATH = dbPath;
+    db = await setupTestDatabaseAt(dbPath);
+    sleeps = [];
+  });
+
+  afterEach(() => {
+    db.$client.close();
+    process.env.CELILO_DB_PATH = undefined;
+    try {
+      rmSync(dir, { recursive: true, force: true });
+    } catch {
+      /* ignore */
+    }
+  });
+
+  function run(overrides: Partial<ControlPlaneBootstrapOptions> = {}) {
+    return bootstrapControlPlane({
+      db,
+      discoverDnsImpl: () => DNS,
+      ensureFleetKeyImpl: () => ({ publicKey: PUBLIC_KEY, created: true }),
+      discoverNetworkImpl: () => ({ applied: ['network.internal.subnet = 10.0.0.0/24'] }),
+      probeDispatcher: () => dispatcher('ok'),
+      sleep: async (ms) => {
+        sleeps.push(ms);
+      },
+      ...overrides,
+    });
+  }
+
+  test('records the discovered DNS and the fleet public key in system config', async () => {
+    await run();
+
+    expect(configValue(db, 'dns.primary')).toBe('9.9.9.9');
+    expect(configValue(db, 'dns.fallback')).toBe('8.8.4.4');
+    expect(configValue(db, 'ssh.public_key')).toBe(PUBLIC_KEY);
+  });
+
+  test('returns what each step found, so the caller renders and this does not', async () => {
+    const result = await run();
+
+    expect(result.dns).toEqual(DNS);
+    expect(result.fleetKey).toEqual({ publicKey: PUBLIC_KEY, created: true });
+    expect(result.network.applied).toEqual(['network.internal.subnet = 10.0.0.0/24']);
+    expect(result.dispatcher.status).toBe('ok');
+  });
+
+  test('a dispatcher already up is probed once and never waited for', async () => {
+    let probes = 0;
+    await run({
+      probeDispatcher: () => {
+        probes++;
+        return dispatcher('ok');
+      },
+    });
+
+    expect(probes).toBe(1);
+    expect(sleeps).toEqual([]);
+  });
+
+  test('a dispatcher still starting is polled until it answers', async () => {
+    // The role enables the supervisor unit moments before this runs, so the
+    // first probe legitimately finds nothing. Two failures then success.
+    const readings: FleetFinding['status'][] = ['fail', 'fail', 'ok'];
+    let probes = 0;
+    const result = await run({
+      probeDispatcher: () => dispatcher(readings[probes++] ?? 'ok'),
+    });
+
+    expect(probes).toBe(3);
+    expect(sleeps).toEqual([1000, 1000]);
+    expect(result.dispatcher.status).toBe('ok');
+  });
+
+  test('a dispatcher that never answers gives up after the attempt budget', async () => {
+    let probes = 0;
+    const result = await run({
+      probeDispatcher: () => {
+        probes++;
+        return dispatcher('fail');
+      },
+      dispatcherAttempts: 5,
+    });
+
+    expect(probes).toBe(5);
+    expect(sleeps).toHaveLength(4);
+    // Reported, not thrown. The caller decides how loud to be, which is what
+    // lets `module deploy` fail the install and a later caller merely warn.
+    expect(result.dispatcher.status).toBe('fail');
+  });
+
+  test('a warn reading is accepted rather than polled against', async () => {
+    let probes = 0;
+    await run({
+      probeDispatcher: () => {
+        probes++;
+        return dispatcher('warn');
+      },
+    });
+
+    expect(probes).toBe(1);
+    expect(sleeps).toEqual([]);
+  });
+
+  test('a box with no default route still gets its DNS and key recorded', async () => {
+    // `discoverAndRecordNetwork` reports a skip rather than throwing, and a
+    // box celilo cannot read a network from must not fail the whole deploy.
+    const result = await run({
+      discoverNetworkImpl: () => ({ applied: [], skipped: 'no default route' }),
+    });
+
+    expect(result.network.skipped).toBe('no default route');
+    expect(configValue(db, 'dns.primary')).toBe('9.9.9.9');
+    expect(configValue(db, 'ssh.public_key')).toBe(PUBLIC_KEY);
+  });
+
+  test('an existing fleet key is recorded without being reminted', async () => {
+    const result = await run({
+      ensureFleetKeyImpl: () => ({ publicKey: PUBLIC_KEY, created: false }),
+    });
+
+    expect(result.fleetKey.created).toBe(false);
+    expect(configValue(db, 'ssh.public_key')).toBe(PUBLIC_KEY);
+  });
+});

package/src/services/control-plane-bootstrap.ts

@@ -0,0 +1,176 @@
+/**
+ * Initialise the management box's own celilo state, during the celilo-mgmt
+ * deploy.
+ *
+ * ## Why this is here and not in a hook
+ *
+ * It was a hook until celilo#1225. `modules/celilo-mgmt/scripts/on_install.ts`
+ * reached every one of these operations by spawning the `celilo` CLI, which a
+ * jailed hook cannot do: the jail's mount set binds no `/usr/bin`, no
+ * `/usr/local/bin` and no shell, so `execFileSync` dies on the missing binary
+ * and `execSync` dies one step earlier on the missing `/bin/sh`. The deploy ran
+ * Ansible to completion and then failed in its own install hook, on every host
+ * where a jail backend exists.
+ *
+ * The fix is not to let the hook reach the CLI. It is that none of this wanted
+ * to be in a hook. celilo-mgmt is never deployed to a remote box (ruled
+ * 2026-09-02), so the host being configured is always the host celilo runs on,
+ * and every step below is celilo acting on itself: read this box's resolvers,
+ * mint celilo's own fleet key, record celilo's own network, check celilo's own
+ * event bus. A hook was a process boundary with celilo on both sides of it.
+ *
+ * ## What it does NOT do
+ *
+ * It does not decide whether to run. The deploy path does that, from the
+ * control-plane module id, which celilo already keys on in three other places
+ * (`manifest/validate.ts`'s privileged allow-list, `capability-loader.ts`'s
+ * `CONTROL_PLANE_MODULE_ID`, `fleet-checks.ts`'s `CONTROL_PLANE_MODULE`).
+ *
+ * It also does not print. It returns what happened and the caller renders it,
+ * so the same function serves a deploy, a test and any later caller without
+ * carrying a logger's opinions (Rule 10.1).
+ */
+
+import { type Bus, defineEvents, openBus } from '@celilo/event-bus';
+import { getEventBusPath } from '../config/paths';
+import type { DbClient } from '../db/client';
+import { type DnsServers, discoverDns } from './dns-discovery';
+import { type FleetFinding, checkDispatcher } from './fleet-checks';
+import { type FleetKey, ensureFleetKey } from './fleet-key';
+import { type NetworkDiscoveryResult, discoverAndRecordNetwork } from './network-discovery';
+import { initializeSystem } from './system-init';
+
+/**
+ * How long to give a dispatcher that is still coming up.
+ *
+ * The Ansible role enables its supervisor unit moments before this runs, so a
+ * first probe legitimately finds nothing. Five one-second attempts is what the
+ * hook this replaced used, and no case has argued for more.
+ */
+const DISPATCHER_ATTEMPTS = 5;
+const DISPATCHER_INTERVAL_MS = 1_000;
+
+export interface ControlPlaneBootstrapOptions {
+  db: DbClient;
+  /** Injectable so tests drive the whole sequence without a host or a bus. */
+  discoverDnsImpl?: () => DnsServers;
+  ensureFleetKeyImpl?: () => FleetKey;
+  discoverNetworkImpl?: (db: DbClient) => NetworkDiscoveryResult;
+  /**
+   * One dispatcher reading. Injectable so a test needs no bus at all; the
+   * default opens celilo's own and runs the four-part check against it.
+   */
+  probeDispatcher?: () => FleetFinding;
+  sleep?: (ms: number) => Promise<void>;
+  dispatcherAttempts?: number;
+}
+
+export interface ControlPlaneBootstrapResult {
+  dns: DnsServers;
+  fleetKey: FleetKey;
+  network: NetworkDiscoveryResult;
+  /** The last dispatcher reading. `fail` means no dispatcher ever answered. */
+  dispatcher: FleetFinding;
+}
+
+/**
+ * The control plane reads the bus's own health tables and emits nothing, so it
+ * registers no event schemas — the same empty registry `celilo events` opens
+ * with.
+ */
+const NO_SCHEMAS = defineEvents({});
+
+/**
+ * Read the dispatcher's state from celilo's own bus.
+ *
+ * `checkDispatcher` is deliberately used in place of the "is the process up?"
+ * read the hook did. Its docblock records why: a naive liveness check reports
+ * green on a dispatcher that is running, unsupervised, on stale code, and
+ * delivering nothing.
+ */
+/**
+ * Open celilo's own bus, do one thing with it, close it.
+ *
+ * There is an async twin below and the two are NOT interchangeable: handing an
+ * async function to this one closes the bus when the promise is CREATED, not
+ * when it settles, so the work runs against a closed handle.
+ */
+export function withCeliloBus<T>(fn: (bus: Bus) => T): T {
+  const bus: Bus = openBus({ dbPath: getEventBusPath(), events: NO_SCHEMAS });
+  try {
+    return fn(bus);
+  } finally {
+    bus.close();
+  }
+}
+
+/** The async twin. See the warning on `withCeliloBus`. */
+export async function withCeliloBusAsync<T>(fn: (bus: Bus) => Promise<T>): Promise<T> {
+  const bus: Bus = openBus({ dbPath: getEventBusPath(), events: NO_SCHEMAS });
+  try {
+    return await fn(bus);
+  } finally {
+    bus.close();
+  }
+}
+
+function probeOwnDispatcher(): FleetFinding {
+  return withCeliloBus((bus) => checkDispatcher(bus));
+}
+
+/** Poll until a dispatcher answers, or the attempts run out. */
+async function waitForDispatcher(
+  probe: () => FleetFinding,
+  attempts: number,
+  sleep: (ms: number) => Promise<void>,
+): Promise<FleetFinding> {
+  let finding = probe();
+  for (let attempt = 1; attempt < attempts && finding.status === 'fail'; attempt++) {
+    await sleep(DISPATCHER_INTERVAL_MS);
+    finding = probe();
+  }
+  return finding;
+}
+
+/**
+ * Record what celilo needs to know about the box it runs on.
+ *
+ * Ordering is not cosmetic. The fleet key and the DNS servers are written in
+ * ONE `initializeSystem` call, because that function applies defaults and the
+ * init sentinel alongside the keys it is given, and calling it twice makes the
+ * second call re-derive everything the first already settled. The hook this
+ * replaced made two round trips through the CLI for exactly that reason and
+ * had no way not to.
+ *
+ * The network is recorded after, not in the same call: `system apply-config`
+ * REFUSES `network.*` keys outright, so a network is not something you write
+ * through the config surface at all. `discoverAndRecordNetwork` is the only
+ * path, it is idempotent, and it never overwrites an operator's value.
+ */
+export async function bootstrapControlPlane(
+  options: ControlPlaneBootstrapOptions,
+): Promise<ControlPlaneBootstrapResult> {
+  const {
+    db,
+    discoverDnsImpl = discoverDns,
+    ensureFleetKeyImpl = ensureFleetKey,
+    discoverNetworkImpl = discoverAndRecordNetwork,
+    probeDispatcher = probeOwnDispatcher,
+    sleep = (ms: number) => new Promise<void>((r) => setTimeout(r, ms)),
+    dispatcherAttempts = DISPATCHER_ATTEMPTS,
+  } = options;
+
+  const dns = discoverDnsImpl();
+  const fleetKey = ensureFleetKeyImpl();
+
+  initializeSystem(db, {
+    'dns.primary': dns.primary,
+    'dns.fallback': dns.fallback,
+    'ssh.public_key': fleetKey.publicKey,
+  });
+
+  const network = discoverNetworkImpl(db);
+  const dispatcher = await waitForDispatcher(probeDispatcher, dispatcherAttempts, sleep);
+
+  return { dns, fleetKey, network, dispatcher };
+}

package/src/services/control-plane-health.test.ts

@@ -0,0 +1,66 @@
+/**
+ * The control plane's health check (celilo#1225).
+ *
+ * The mapping is what these pin. The failure that made this code exist was not
+ * a wrong assertion — the hook's `existsSync(db_path)` was a perfectly correct
+ * question — it was a correct question asked from inside a jail that does not
+ * bind the directory, so a present database read as absent. Nothing in a unit
+ * test can catch that shape; what a unit test CAN hold is that every finding
+ * reaches the operator with its status and its remediation intact, because the
+ * unattended path is the one nobody is watching.
+ */
+
+import { describe, expect, test } from 'bun:test';
+import { findingAsHealthCheck } from './control-plane-health';
+import type { FleetFinding } from './fleet-checks';
+
+function finding(over: Partial<FleetFinding> = {}): FleetFinding {
+  return {
+    id: 'dispatcher',
+    title: 'Event dispatcher',
+    status: 'ok',
+    summary: 'a dispatcher is live',
+    detail: [],
+    remediation: null,
+    autoFixable: false,
+    ...over,
+  };
+}
+
+describe('findingAsHealthCheck', () => {
+  test("ok becomes pass — celilo's vocabulary is not the health path's", () => {
+    expect(findingAsHealthCheck(finding({ status: 'ok' })).status).toBe('pass');
+    expect(findingAsHealthCheck(finding({ status: 'warn' })).status).toBe('warn');
+    expect(findingAsHealthCheck(finding({ status: 'fail' })).status).toBe('fail');
+  });
+
+  test('the check is named by the finding id, so an operator can grep for it', () => {
+    const item = findingAsHealthCheck(finding({ id: 'schema_drift' }));
+    expect(item.name).toBe('schema_drift');
+    expect(item.message).toBe('a dispatcher is live');
+  });
+
+  test('the remediation survives the mapping', () => {
+    // This is the line that tells an operator what to DO, and the health path
+    // is the one that runs unattended every fifteen minutes. Dropping it here
+    // would leave a failing check with no next step, quietly.
+    const item = findingAsHealthCheck(
+      finding({
+        status: 'fail',
+        detail: ['no live dispatcher — heartbeat absent'],
+        remediation: 'systemctl enable --now celilo-events.service',
+      }),
+    );
+    expect(item.details).toContain('no live dispatcher — heartbeat absent');
+    expect(item.details).toContain('Fix: systemctl enable --now celilo-events.service');
+  });
+
+  test('a healthy finding carries no empty details field', () => {
+    expect(findingAsHealthCheck(finding()).details).toBeUndefined();
+  });
+
+  test('detail lines survive without a remediation', () => {
+    const item = findingAsHealthCheck(finding({ status: 'warn', detail: ['two dispatchers'] }));
+    expect(item.details).toBe('two dispatchers');
+  });
+});

package/src/services/control-plane-health.ts

@@ -0,0 +1,67 @@
+/**
+ * The control plane's health check, run by celilo rather than by a hook.
+ *
+ * ## Why this is not a hook
+ *
+ * It was `modules/celilo-mgmt/scripts/health-check.ts` until celilo#1225, and
+ * it failed under the hook jail in the way that is worst: **it reported a
+ * healthy fleet's database missing.** The hook asked `existsSync(db_path)`,
+ * the jail does not bind celilo's data directory (deliberately — that is where
+ * `master.key` and `celilo.db` live), so the answer was `false` and the deploy
+ * failed on a file that was sitting right there. Its other two checks shelled
+ * out to the CLI, which a jailed hook cannot reach at all.
+ *
+ * Every one of those was celilo inspecting itself. Deleting `on_install` for
+ * that reason and leaving this behind would have fixed one hook and left the
+ * deploy failing on the next.
+ *
+ * ## What replaced it is stronger, not merely relocated
+ *
+ * The hook asked two questions: does a file exist, and is this hostname in
+ * `celilo machine list`. `runFleetChecks` is what celilo already runs for
+ * `celilo system doctor`, and it asks eight, including the four-part dispatcher
+ * probe whose whole point is that "a process is up" reports green on a
+ * dispatcher that is unsupervised, on stale code, and delivering nothing.
+ *
+ * So the module gets a better check by having none of its own. That is the
+ * outcome to keep in mind before anyone adds a hook back: a health_check hook
+ * here can only re-ask, worse, questions celilo can answer directly.
+ */
+
+import type { DbClient } from '../db/client';
+import { withCeliloBusAsync } from './control-plane-bootstrap';
+import { type FleetFinding, runFleetChecks } from './fleet-checks';
+import type { HealthCheckItem } from './health-runner';
+
+/** `FleetFinding`'s three statuses in `HealthCheckItem`'s vocabulary. */
+const STATUS: Record<FleetFinding['status'], HealthCheckItem['status']> = {
+  ok: 'pass',
+  warn: 'warn',
+  fail: 'fail',
+};
+
+/**
+ * One finding as a health item.
+ *
+ * `detail` and `remediation` are folded into `details` rather than dropped:
+ * the health path is what runs unattended every fifteen minutes, so the line
+ * telling an operator what to DO has to survive the mapping.
+ */
+export function findingAsHealthCheck(finding: FleetFinding): HealthCheckItem {
+  const details = [
+    ...finding.detail,
+    ...(finding.remediation ? [`Fix: ${finding.remediation}`] : []),
+  ];
+  return {
+    name: finding.id,
+    status: STATUS[finding.status],
+    message: finding.summary,
+    ...(details.length > 0 ? { details: details.join('\n') } : {}),
+  };
+}
+
+/** Run celilo's own fleet checks and report them as the control plane's health. */
+export async function controlPlaneHealthChecks(db: DbClient): Promise<HealthCheckItem[]> {
+  const findings = await withCeliloBusAsync((bus) => runFleetChecks(bus, db));
+  return findings.map(findingAsHealthCheck);
+}

package/src/services/deployed-systems.ts

@@ -48,6 +48,18 @@ function rowToSystem(row: typeof moduleSystems.$inferSelect): DeployedSystem {
  * Returns [] for API-only modules (e.g. namecheap) — that is a modeled state,
  * not an error.
  */
+/**
+ * The module that IS celilo's control plane.
+ *
+ * celilo knows this module by name in several places — its privileged
+ * capability allow-list, the subnet it trusts, the fleet checks that ask where
+ * the control plane runs, and the deploy step that initialises the box's own
+ * state. The id lives here because every one of those already reaches for
+ * `getModuleSystems`, and three separate private copies of the string is how
+ * they drift.
+ */
+export const CONTROL_PLANE_MODULE_ID = 'celilo-mgmt';
+
 export function getModuleSystems(moduleId: string, db: DbClient): DeployedSystem[] {
   const rows = db.select().from(moduleSystems).where(eq(moduleSystems.moduleId, moduleId)).all();
   return rows.map(rowToSystem).sort((a, b) => a.name.localeCompare(b.name));

package/src/services/dns-discovery.test.ts

@@ -0,0 +1,93 @@
+/**
+ * Moved from `modules/celilo-mgmt/scripts/discovery.test.ts` with celilo#1225.
+ *
+ * The parser cases came across unchanged. The `discoverDns` cases are new and
+ * could not have been written there: the module's version read the filesystem
+ * directly, so the file-preference rule — the part with the actual failure mode
+ * — had no seam to test through.
+ */
+
+import { describe, expect, test } from 'bun:test';
+import { type ResolverFileReader, chooseDns, discoverDns, parseNameservers } from './dns-discovery';
+
+const SYSTEMD = '/run/systemd/resolve/resolv.conf';
+const ETC = '/etc/resolv.conf';
+
+/** A host offering exactly the files given, and nothing else. */
+function host(files: Record<string, string>): ResolverFileReader {
+  return (path) => files[path] ?? null;
+}
+
+describe('parseNameservers', () => {
+  test('extracts nameserver IPs in order', () => {
+    const resolv = ['# comment', 'nameserver 9.9.9.9', 'nameserver 8.8.4.4', 'search lan'].join(
+      '\n',
+    );
+    expect(parseNameservers(resolv)).toEqual(['9.9.9.9', '8.8.4.4']);
+  });
+
+  test('returns empty for no nameservers', () => {
+    expect(parseNameservers('search lan\noptions edns0')).toEqual([]);
+  });
+});
+
+describe('chooseDns', () => {
+  test('drops loopback stubs (systemd-resolved 127.0.0.53)', () => {
+    expect(chooseDns(['127.0.0.53'])).toEqual({ primary: '1.1.1.1', fallback: '1.1.1.1' });
+  });
+
+  test('uses the first two real upstreams', () => {
+    expect(chooseDns(['9.9.9.9', '8.8.4.4', '1.0.0.1'])).toEqual({
+      primary: '9.9.9.9',
+      fallback: '8.8.4.4',
+    });
+  });
+
+  test('falls back to 1.1.1.1 for the second when only one upstream', () => {
+    expect(chooseDns(['9.9.9.9'])).toEqual({ primary: '9.9.9.9', fallback: '1.1.1.1' });
+  });
+});
+
+describe('discoverDns', () => {
+  test('prefers the systemd upstream file over the stub in /etc/resolv.conf', () => {
+    // The case the file order exists for. Reading only /etc/resolv.conf here
+    // discovers 127.0.0.53, which no other box on the network can reach.
+    const servers = discoverDns(
+      host({
+        [SYSTEMD]: 'nameserver 9.9.9.9\nnameserver 8.8.4.4\n',
+        [ETC]: 'nameserver 127.0.0.53\n',
+      }),
+    );
+    expect(servers).toEqual({ primary: '9.9.9.9', fallback: '8.8.4.4' });
+  });
+
+  test('falls through to /etc/resolv.conf when the systemd file yields nothing real', () => {
+    const servers = discoverDns(
+      host({
+        [SYSTEMD]: 'nameserver 127.0.0.53\n',
+        [ETC]: 'nameserver 192.0.2.10\nnameserver 192.0.2.11\n',
+      }),
+    );
+    expect(servers).toEqual({ primary: '192.0.2.10', fallback: '192.0.2.11' });
+  });
+
+  test('reads /etc/resolv.conf on a host with no systemd resolver file', () => {
+    expect(discoverDns(host({ [ETC]: 'nameserver 192.0.2.10\n' }))).toEqual({
+      primary: '192.0.2.10',
+      fallback: '1.1.1.1',
+    });
+  });
+
+  test('accepts a loopback-only /etc/resolv.conf as the public fallback, not as an error', () => {
+    // Last resort: whatever it gives is taken, and a stub-only host yields the
+    // public fallback rather than an unreachable address.
+    expect(discoverDns(host({ [ETC]: 'nameserver 127.0.0.53\n' }))).toEqual({
+      primary: '1.1.1.1',
+      fallback: '1.1.1.1',
+    });
+  });
+
+  test('returns the public fallback on a host with no resolver files at all', () => {
+    expect(discoverDns(host({}))).toEqual({ primary: '1.1.1.1', fallback: '1.1.1.1' });
+  });
+});