@celilo/cli 2.0.0 → 2.2.0

package/src/services/bus-interview.ts

@@ -16,7 +16,7 @@
 
 import { type Bus, defineEvents, openBus } from '@celilo/event-bus';
 import { getEventBusPath } from '../config/paths';
-import { InterviewAbandonedError } from './interview-errors';
+import { InterviewAbandonedError, InterviewUnansweredError } from './interview-errors';
 import { ensureResponderForInterview } from './responder-probe';
 
 const NO_SCHEMAS = defineEvents({});
@@ -271,17 +271,26 @@ export async function busInterview<TReply>(
   type: string,
   payload: object,
   ownerBus?: Bus,
+  timeoutMs = 0,
 ): Promise<TReply> {
   const ownsBus = !ownerBus;
   const bus: Bus = ownerBus ?? openBus({ dbPath: getEventBusPath(), events: NO_SCHEMAS });
   try {
     const replies = await bus.query(type as never, payload as never, {
-      timeoutMs: 0, // wait forever — race semantics, no timeout
+      timeoutMs, // 0 = wait forever — race semantics, no timeout
       pollIntervalMs: 250,
       expect: 'first',
     });
     if (replies.length === 0) {
-      throw new Error(`bus-interview: ${type} returned no reply`);
+      // Typed so a bounded caller can distinguish "nobody answered in time"
+      // from a decline. With the default 0 this is unreachable (the query
+      // waits forever), but keeping it typed costs nothing.
+      throw new InterviewUnansweredError(
+        type,
+        timeoutMs > 0
+          ? `No reply within ${timeoutMs}ms (${type})`
+          : `bus-interview: ${type} returned no reply`,
+      );
     }
     return replies[0].payload as unknown as TReply;
   } finally {
@@ -305,9 +314,10 @@ export async function busInterviewGuarded<TReply>(
   type: string,
   payload: object,
   ownerBus?: Bus,
+  timeoutMs = 0,
 ): Promise<TReply> {
   await ensureResponderForInterview(type);
-  return busInterview<TReply>(type, payload, ownerBus);
+  return busInterview<TReply>(type, payload, ownerBus, timeoutMs);
 }
 
 /**
@@ -326,9 +336,10 @@ export async function busInterviewGuarded<TReply>(
 export async function askInterview(
   payload: InterviewRequiredPayload,
   ownerBus?: Bus,
+  timeoutMs = 0,
 ): Promise<unknown> {
   const type = EVENT_TYPES.interviewRequired(payload.scope, payload.key);
-  const reply = await busInterviewGuarded<InterviewReply>(type, payload, ownerBus);
+  const reply = await busInterviewGuarded<InterviewReply>(type, payload, ownerBus, timeoutMs);
   if (reply.abandoned) throw new InterviewAbandonedError(type, reply.abandoned.reason);
   return reply.value;
 }
@@ -463,16 +474,28 @@ export async function askConfirm(opts: {
   message: string;
   defaultValue?: boolean;
   description?: string;
+  /**
+   * Bound the wait for a reply. 0 (the default) waits forever, which is
+   * right when the operator IS the responder (TTY). A headless caller whose
+   * responder may be attached but not staged for this question passes a
+   * finite bound so it skips instead of hanging until the suite budget
+   * kills it (module-orchestrator-primitives design.md D5).
+   */
+  timeoutMs?: number;
 }): Promise<boolean> {
-  const value = await askInterview({
-    scope: opts.scope,
-    key: opts.key,
-    kind: 'confirm',
-    message: opts.message,
-    required: true,
-    defaultValue: opts.defaultValue === undefined ? undefined : String(opts.defaultValue),
-    description: opts.description,
-  });
+  const value = await askInterview(
+    {
+      scope: opts.scope,
+      key: opts.key,
+      kind: 'confirm',
+      message: opts.message,
+      required: true,
+      defaultValue: opts.defaultValue === undefined ? undefined : String(opts.defaultValue),
+      description: opts.description,
+    },
+    undefined,
+    opts.timeoutMs,
+  );
   if (typeof value !== 'boolean') {
     throw new Error(
       `askConfirm(${opts.scope}.${opts.key}): expected a boolean reply, got ${typeof value}`,

package/src/services/config-provenance.ts

@@ -74,6 +74,8 @@ export function describeDerivedSource(variable: VariableDeclare): string {
       return 'from the infrastructure celilo selected for this module';
     case 'terraform':
       return 'from a Terraform output, at deploy time';
+    case 'hook':
+      return `by the module's own hooks at runtime (via context.config.set), and never by an operator`;
     default:
       return `computed by celilo (source: ${variable.source})`;
   }
@@ -98,6 +100,8 @@ export function explainNotSettable(moduleId: string, variable: VariableDeclare):
       return `${header}\n${origin}\n  • node placement: set the service default for NEW deploys (celilo service reconfigure); move an existing container with 'celilo proxmox migrate'.\n  • vmid / IP: auto-allocated by IPAM.`;
     case 'terraform':
       return `${header}\n${origin}\n  • It is read back from Terraform outputs after the deploy creates the resource.`;
+    case 'hook':
+      return `${header}\n${origin}\n  • It is written by the module's own hook via context.config.set, not by any operator path.`;
     default:
       return `${header}\n${origin}`;
   }

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

@@ -0,0 +1,297 @@
+/**
+ * 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 { capabilities, modules, 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('hands discovery every address a deployed resolver advertises (celilo#1239)', async () => {
+    // The recurrence gate's second half: the refusal only works if bootstrap
+    // actually tells discovery what to refuse. Seed capability rows the way a
+    // deployed resolver provider (technitium) and its secondary
+    // (knot-unbound-secondary) write them, including the CIDR suffix IPAM
+    // resolves target_ip to. Selection is by the declared `fleet_resolver`
+    // marker in the data, never the capability name.
+    const [module] = db
+      .insert(modules)
+      .values({
+        id: 'technitium',
+        name: 'technitium',
+        version: '1.0.0',
+        manifestData: {},
+        sourcePath: '/test/technitium',
+      })
+      .returning()
+      .all();
+    db.insert(capabilities)
+      .values([
+        {
+          moduleId: module.id,
+          capabilityName: 'dns_internal',
+          version: '1.0.0',
+          data: {
+            fleet_resolver: true,
+            server: { ip: '10.0.10.13', internal_ip: '192.168.0.151/24' },
+          },
+        },
+        {
+          moduleId: module.id,
+          capabilityName: 'dns_internal_secondary',
+          version: '1.0.0',
+          data: { fleet_resolver: true, server: { ip: '10.0.20.14' } },
+        },
+      ])
+      .run();
+
+    const seen: string[][] = [];
+    await run({
+      discoverDnsImpl: (fleetResolverIps) => {
+        seen.push([...fleetResolverIps]);
+        return DNS;
+      },
+    });
+
+    expect(seen).toHaveLength(1);
+    expect(seen[0].sort()).toEqual(['10.0.10.13', '192.168.0.151/24', '10.0.20.14'].sort());
+  });
+
+  test('a resolver capability without the declared marker is not a fleet resolver', async () => {
+    // Selection is by the DECLARED marker, not the capability name. A row
+    // named like a resolver but not declaring fleet_resolver must be ignored,
+    // otherwise renaming this to a name check would pass every other test
+    // here and silently re-open celilo#1239 to name-shaped drift.
+    const [module] = db
+      .insert(modules)
+      .values({
+        id: 'technitium',
+        name: 'technitium',
+        version: '1.0.0',
+        manifestData: {},
+        sourcePath: '/test/technitium',
+      })
+      .returning()
+      .all();
+    db.insert(capabilities)
+      .values({
+        moduleId: module.id,
+        capabilityName: 'dns_internal',
+        version: '1.0.0',
+        data: { server: { ip: '10.0.10.13', internal_ip: '192.168.0.151/24' } },
+      })
+      .run();
+
+    const seen: string[][] = [];
+    await run({
+      discoverDnsImpl: (fleetResolverIps) => {
+        seen.push([...fleetResolverIps]);
+        return DNS;
+      },
+    });
+
+    expect(seen).toEqual([[]]);
+  });
+
+  test('a capability of any name declaring the marker is a fleet resolver', async () => {
+    // The other half of the same proof: a NEW resolver provider needs no core
+    // change. Its capability name is irrelevant; the declaration is what counts.
+    const [module] = db
+      .insert(modules)
+      .values({
+        id: 'technitium',
+        name: 'technitium',
+        version: '1.0.0',
+        manifestData: {},
+        sourcePath: '/test/technitium',
+      })
+      .returning()
+      .all();
+    db.insert(capabilities)
+      .values({
+        moduleId: module.id,
+        capabilityName: 'some_future_resolver',
+        version: '1.0.0',
+        data: { fleet_resolver: true, server: { ip: '10.0.30.15' } },
+      })
+      .run();
+
+    const seen: string[][] = [];
+    await run({
+      discoverDnsImpl: (fleetResolverIps) => {
+        seen.push([...fleetResolverIps]);
+        return DNS;
+      },
+    });
+
+    expect(seen).toEqual([['10.0.30.15']]);
+  });
+
+  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,223 @@
+/**
+ * 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 { capabilities } from '../db/schema';
+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;
+
+/**
+ * The marker a resolver provider declares in its capability data to say "the
+ * addresses I advertise are a resolver celilo itself deployed". Core reads
+ * this declaration and names no capability (module-business-barrier Scan B).
+ * Declared today by knot-unbound-internal, knot-unbound-secondary and
+ * technitium (celilo#1239).
+ */
+const FLEET_RESOLVER_MARKER = 'fleet_resolver';
+
+/** The declared shape of a resolver capability's data. Values checked before use. */
+type ResolverCapabilityData = {
+  fleet_resolver?: unknown;
+  server?: { ip?: unknown; internal_ip?: unknown };
+};
+
+/**
+ * Every address a deployed resolver provider advertises for itself.
+ *
+ * A capability row counts when its data declares {@link FLEET_RESOLVER_MARKER};
+ * the capability NAME is irrelevant to this selection, so a new resolver
+ * provider needs no core change. Discovery hands the addresses to
+ * {@link discoverDns} so a resolv.conf the provider's own aspect wrote is
+ * refused rather than adopted as the fleet's upstream (celilo#1239). Addresses
+ * come from the declared data only (`server.ip`, `server.internal_ip`). Values
+ * may carry a CIDR suffix; discovery normalises both sides before comparing.
+ */
+export function fleetResolverAddresses(db: DbClient): string[] {
+  const addresses: string[] = [];
+  const rows = db.select({ data: capabilities.data }).from(capabilities).all();
+  for (const row of rows) {
+    const data = row.data as ResolverCapabilityData | undefined;
+    if (data?.[FLEET_RESOLVER_MARKER] !== true) continue;
+    for (const value of [data.server?.ip, data.server?.internal_ip]) {
+      if (typeof value === 'string' && value.length > 0) {
+        addresses.push(value);
+      }
+    }
+  }
+  return addresses;
+}
+
+export interface ControlPlaneBootstrapOptions {
+  db: DbClient;
+  /**
+   * Injectable so tests drive the whole sequence without a host or a bus.
+   * Receives the addresses of resolvers celilo itself deployed, which the
+   * discovery must refuse (celilo#1239).
+   */
+  discoverDnsImpl?: (fleetResolverIps: readonly string[]) => 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 = (fleetResolverIps: readonly string[]): DnsServers =>
+      discoverDns(undefined, { fleetResolverIps }),
+    ensureFleetKeyImpl = ensureFleetKey,
+    discoverNetworkImpl = discoverAndRecordNetwork,
+    probeDispatcher = probeOwnDispatcher,
+    sleep = (ms: number) => new Promise<void>((r) => setTimeout(r, ms)),
+    dispatcherAttempts = DISPATCHER_ATTEMPTS,
+  } = options;
+
+  const dns = discoverDnsImpl(fleetResolverAddresses(db));
+  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 };
+}