@robota-sdk/agent-transport-webrtc 3.0.0-beta.100

package/src/__tests__/mesh-turn-relay.test.ts

@@ -0,0 +1,161 @@
+import { createIdentityContext } from '@robota-sdk/agent-remote-pairing';
+const testIdentity = createIdentityContext('test-product');
+import { derivePairRendezvous, type IPairRendezvous } from '@robota-sdk/agent-remote-pairing';
+import { afterEach, beforeAll, describe, expect, it } from 'vitest';
+
+import {
+  MAX_RELAY_CREDENTIAL_TTL_MS,
+  MeshTurnRelay,
+  meshRelayCredential,
+  meshRelayIceServers,
+} from '../mesh-turn-relay.js';
+import { buildMeshWorld, type IMeshTestDevice, type IMeshTestWorld } from './mesh-fixtures.js';
+import { TurnTestClient } from './turn-test-client.js';
+
+let world: IMeshTestWorld;
+let stranger: IMeshTestDevice;
+const relays: MeshTurnRelay[] = [];
+const clients: TurnTestClient[] = [];
+
+beforeAll(async () => {
+  world = await buildMeshWorld();
+  // A device of the same user that the lists in force do not name.
+  stranger = (await buildMeshWorld()).third;
+});
+
+afterEach(async () => {
+  for (const client of clients.splice(0)) client.close();
+  for (const relay of relays.splice(0)) await relay.close();
+});
+
+/** `own`'s rendezvous with `peer`, under the world's lists or the ones given. */
+function pair(
+  own: IMeshTestDevice,
+  peer: IMeshTestDevice,
+  devices: readonly IMeshTestDevice[] = [world.low, world.high, world.third],
+): Promise<IPairRendezvous> {
+  return derivePairRendezvous(testIdentity, {
+    ownKaPrivateKey: own.ka.privateKey,
+    own: own.cert,
+    peerDeviceId: peer.cert.deviceId,
+    lists: {
+      roster: { devices: devices.map((d) => d.cert) },
+      revocation: { revokedDeviceIds: [] },
+    },
+  });
+}
+
+/** `third` runs the relay for `low` and `high`. */
+async function relayOnThird(now: () => number = Date.now): Promise<MeshTurnRelay> {
+  const relay = await MeshTurnRelay.start({ host: '127.0.0.1', port: 0, now });
+  relays.push(relay);
+  relay.declarePeers([
+    { deviceId: world.low.cert.deviceId, rendezvous: await pair(world.third, world.low) },
+    { deviceId: world.high.cert.deviceId, rendezvous: await pair(world.third, world.high) },
+  ]);
+  return relay;
+}
+
+async function client(
+  relay: MeshTurnRelay,
+  credential: { readonly username: string; readonly credential: string },
+): Promise<TurnTestClient> {
+  const created = await TurnTestClient.connect(
+    { address: relay.endpoint.host, port: relay.endpoint.port },
+    credential.username,
+    credential.credential,
+  );
+  clients.push(created);
+  return created;
+}
+
+describe('embedded TURN relay — pairwise, short-lived credentials', () => {
+  it('a roster device allocates with the credential it derives for the pair; the username names no device', async () => {
+    const relay = await relayOnThird();
+    const credential = await meshRelayCredential(await pair(world.low, world.third), Date.now());
+    expect(credential.username).toMatch(/^\d+:[A-Za-z0-9_-]{22}$/);
+    expect(credential.username).not.toContain(world.low.cert.deviceId.slice(0, 8));
+
+    const answer = await (await client(relay, credential)).allocate();
+
+    expect(answer.ok).toBe(true);
+    expect(relay.allocationCount(world.low.cert.deviceId)).toBe(1);
+    expect(relay.allocationCount(world.high.cert.deviceId)).toBe(0);
+  });
+
+  it('ICE servers carry the credential for every advertised endpoint of the relay', async () => {
+    const servers = await meshRelayIceServers(
+      await pair(world.low, world.third),
+      [
+        { host: '192.0.2.1', port: 3478 },
+        { host: '2001:db8::1', port: 3479 },
+      ],
+      Date.now(),
+    );
+    expect(servers.map((s) => s.urls)).toEqual([
+      'turn:192.0.2.1:3478?transport=udp',
+      'turn:[2001:db8::1]:3479?transport=udp',
+    ]);
+    expect(new Set(servers.map((s) => s.username)).size).toBe(1);
+  });
+
+  it('a device outside the roster is refused, even with a genuine pairwise secret', async () => {
+    const relay = await relayOnThird();
+    // The stranger agrees a secret with the relay device under lists of its own making.
+    const own = await pair(stranger, world.third, [world.third, stranger]);
+    const answer = await (
+      await client(relay, await meshRelayCredential(own, Date.now()))
+    ).allocate();
+    expect(answer.ok).toBe(false);
+    expect(answer.code).toBe(401);
+    expect(relay.allocationCount()).toBe(0);
+  });
+
+  it("another pair's credential, or a wrong password, is refused", async () => {
+    const relay = await relayOnThird();
+    // low's credential for its pair with high is not a credential for the relay device.
+    const other = await meshRelayCredential(await pair(world.low, world.high), Date.now());
+    expect((await (await client(relay, other)).allocate()).code).toBe(401);
+    const right = await meshRelayCredential(await pair(world.low, world.third), Date.now());
+    const wrong = await client(relay, { username: right.username, credential: 'x'.repeat(43) });
+    expect((await wrong.allocate()).code).toBe(401);
+    expect(relay.allocationCount()).toBe(0);
+  });
+
+  it('an expired credential, or one that claims to live longer than a relay accepts, is refused', async () => {
+    let now = Date.now();
+    const relay = await relayOnThird(() => now);
+    const rendezvous = await pair(world.low, world.third);
+    const expiring = await meshRelayCredential(rendezvous, now, 60_000);
+    now += 61_000;
+    expect((await (await client(relay, expiring)).allocate()).code).toBe(401);
+
+    // Minted by hand past the longest lifetime (meshRelayCredential clamps it).
+    const tag = (await meshRelayCredential(rendezvous, now)).username.split(':')[1]!;
+    const username = `${Math.floor((now + MAX_RELAY_CREDENTIAL_TTL_MS + 5 * 60_000) / 1000)}:${tag}`;
+    const longLived = {
+      username,
+      credential: await rendezvous.relayPassword('outbound', username),
+    };
+    expect((await (await client(relay, longLived)).allocate()).code).toBe(401);
+    expect(relay.allocationCount()).toBe(0);
+  });
+
+  it("a revoked device's credential stops working and its allocations close at once", async () => {
+    const relay = await relayOnThird();
+    const credential = await meshRelayCredential(await pair(world.high, world.third), Date.now());
+    const allocated = await client(relay, credential);
+    expect((await allocated.allocate()).ok).toBe(true);
+
+    // The lists in force now revoke high: only low stays a peer of the relay.
+    relay.declarePeers([
+      { deviceId: world.low.cert.deviceId, rendezvous: await pair(world.third, world.low) },
+    ]);
+
+    expect(relay.allocationCount(world.high.cert.deviceId)).toBe(0);
+    // Nothing is left to refresh, and the credential no longer authenticates anything.
+    expect((await allocated.refresh(600)).code).toBe(401);
+    const again = await client(relay, credential);
+    expect((await again.allocate()).code).toBe(401);
+  });
+});

package/src/__tests__/negotiated-certificate.test.ts

@@ -0,0 +1,76 @@
+import { extractDtlsFingerprint } from '@robota-sdk/agent-remote-pairing';
+import { describe, expect, it } from 'vitest';
+
+import { whenRemoteCertificateVerified } from '../negotiated-certificate.js';
+import { RtcPeer } from '../rtc-peer.js';
+
+interface IPair {
+  readonly host: RtcPeer;
+  readonly remote: RtcPeer;
+  readonly offer: string;
+  readonly answer: string;
+}
+
+/** Connect two real peers directly; `tamperAnswer` rewrites the answer the host consumes. */
+async function connectedPair(tamperAnswer: (sdp: string) => string = (sdp) => sdp): Promise<IPair> {
+  const host = new RtcPeer();
+  const remote = new RtcPeer();
+  host.createDataChannel('agent-session');
+  const toRemote: { candidate: string; mid: string }[] = [];
+  const toHost: { candidate: string; mid: string }[] = [];
+  host.onLocalCandidate((c) => toRemote.push(c));
+  remote.onLocalCandidate((c) => toHost.push(c));
+  const offer = await host.createOffer();
+  const answer = await remote.acceptOffer(offer);
+  host.acceptAnswer(tamperAnswer(answer));
+  // Candidates keep arriving after the descriptions; deliver them for a while.
+  const deliver = setInterval(() => {
+    for (const c of toRemote.splice(0)) remote.addRemoteCandidate(c);
+    for (const c of toHost.splice(0)) host.addRemoteCandidate(c);
+  }, 20);
+  setTimeout(() => clearInterval(deliver), 5_000).unref();
+  return { host, remote, offer, answer };
+}
+
+function verified(peer: RtcPeer, algorithm = 'sha-256'): Promise<string> {
+  return new Promise<string>((resolve, reject) => {
+    whenRemoteCertificateVerified(peer, algorithm, resolve, (reason) => reject(new Error(reason)));
+  });
+}
+
+describe('negotiated certificate fingerprint', () => {
+  it('reports the fingerprint of the certificate the DTLS layer accepted, on both sides', async () => {
+    const { host, remote, offer, answer } = await connectedPair();
+    await expect(verified(host)).resolves.toBe(extractDtlsFingerprint(answer));
+    await expect(verified(remote)).resolves.toBe(extractDtlsFingerprint(offer));
+    host.close();
+    remote.close();
+  }, 15_000);
+
+  it('gives every connection a certificate of its own', async () => {
+    const first = await connectedPair();
+    const second = await connectedPair();
+    const fingerprints = new Set(
+      [first.offer, first.answer, second.offer, second.answer].map(extractDtlsFingerprint),
+    );
+    expect(fingerprints.size).toBe(4);
+    for (const peer of [first.host, first.remote, second.host, second.remote]) peer.close();
+  }, 15_000);
+
+  it('fails when the certificate was checked with another algorithm than the description names', async () => {
+    const { host, remote } = await connectedPair();
+    await expect(verified(host, 'sha-384')).rejects.toThrow(/checked with sha-256, not sha-384/);
+    host.close();
+    remote.close();
+  }, 15_000);
+
+  it('reports a DTLS handshake that fails because the description names another certificate', async () => {
+    const bogus = Array.from({ length: 32 }, () => 'AA').join(':');
+    const { host, remote } = await connectedPair((sdp) =>
+      sdp.replace(/a=fingerprint:(\S+) (\S+)/, `a=fingerprint:$1 ${bogus}`),
+    );
+    await expect(verified(host)).rejects.toThrow(/ended (failed|closed)/);
+    host.close();
+    remote.close();
+  }, 30_000);
+});

package/src/__tests__/nostr-source-condition.test.ts

@@ -0,0 +1,27 @@
+/**
+ * The workspace runs from source with `--conditions=source` (`pnpm cli:dev`, the scenario scripts), and
+ * Node applies a condition to every package. `nostr-tools` declares its own `source` condition pointing at
+ * `.ts` files its tarball does not ship, so every source run failed on `nostr-tools/pool.ts`. The root
+ * `patchedDependencies` entry removes that condition; this loads the subpaths the transport imports the
+ * way a source run does.
+ */
+
+import { spawnSync } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+
+import { describe, expect, it } from 'vitest';
+
+const PACKAGE_DIR = fileURLToPath(new URL('../..', import.meta.url));
+
+describe('nostr-tools under the source export condition', () => {
+  it.each(['nostr-tools/pool', 'nostr-tools/pure'])('loads %s', (specifier) => {
+    const result = spawnSync(
+      process.execPath,
+      ['--conditions=source', '--input-type=module', '-e', `await import('${specifier}');`],
+      { cwd: PACKAGE_DIR, encoding: 'utf8', timeout: 20_000 },
+    );
+
+    expect(result.stderr).not.toContain('ERR_MODULE_NOT_FOUND');
+    expect(result.status).toBe(0);
+  });
+});

package/src/__tests__/operator-approval-gate.test.ts

@@ -0,0 +1,308 @@
+import { createIdentityContext } from '@robota-sdk/agent-remote-pairing';
+const testIdentity = createIdentityContext('test-product');
+import { createTestInteractiveSession } from '@robota-sdk/agent-interface-session/testing';
+import {
+  deriveIdentityId,
+  exportPublicKey,
+  generateIdentityKeyPair,
+  importPublicKey,
+  startDeviceReconnect,
+  type TReconnectFrame,
+} from '@robota-sdk/agent-remote-pairing';
+import { describe, expect, it, vi } from 'vitest';
+
+import { nextAdmissionStep } from '../admission-steps.js';
+import {
+  PairingGate,
+  type IConnectionApproval,
+  type IConnectionApprovalContext,
+  type IHostReconnectConfig,
+  type IPairingGateOptions,
+} from '../pairing-gate.js';
+
+import type { createSessionMessageHandler } from '@robota-sdk/agent-transport';
+
+/**
+ * A connection that would drive the session is the receiving operator's to allow, every time: the
+ * handshake proves who is on the other end, and the operator decides whether that device drives now.
+ * Until they say yes nothing reaches the session, and a device they refuse is not remembered.
+ */
+
+const FP = { localFingerprint: 'HOST:FP', remoteFingerprint: 'DEV:FP' };
+
+function deferred(): { promise: Promise<boolean>; resolve: (value: boolean) => void } {
+  let resolve!: (value: boolean) => void;
+  const promise = new Promise<boolean>((res) => {
+    resolve = res;
+  });
+  return { promise, resolve };
+}
+
+function makeGate(over: Partial<IPairingGateOptions> = {}) {
+  const sent: unknown[] = [];
+  let closed = false;
+  const channel = {
+    send: (d: string) => {
+      sent.push(JSON.parse(d));
+    },
+    close: () => {
+      closed = true;
+    },
+  };
+  const sessionOnMessage = vi.fn();
+  const createHandler: typeof createSessionMessageHandler = () => ({
+    onMessage: sessionOnMessage,
+    cleanup: vi.fn(),
+  });
+  const onAccept = vi.fn();
+  const onReject = vi.fn();
+  const fakeHandshake = (() => ({
+    result: Promise.resolve({ sessionKey: 'k' }),
+    onFrame: () => {},
+  })) as never;
+  const gate = new PairingGate({cryptoContext: testIdentity,
+    channel,
+    session: createTestInteractiveSession(),
+    secret: 's',
+    role: 'initiator',
+    ...FP,
+    startHandshake: fakeHandshake,
+    createHandler,
+    onAccept,
+    onReject,
+    ...over,
+  });
+  return { gate, sent, closed: () => closed, sessionOnMessage, onAccept, onReject };
+}
+
+async function flush(): Promise<void> {
+  for (let i = 0; i < 5; i += 1) await Promise.resolve();
+}
+
+describe('operator approval of a driving connection', () => {
+  it('is the last step owed, after every proof the channel owes', () => {
+    const configured = { localPeer: {}, handoffGrant: {}, connectionApproval: {} };
+    expect(nextAdmissionStep({ connectionApproval: {} }, 'pairing')).toBe('operator-approval');
+    expect(nextAdmissionStep(configured, 'pairing')).toBe('local-proof');
+    expect(nextAdmissionStep(configured, 'local-proof')).toBe('handoff-grant');
+    expect(nextAdmissionStep(configured, 'handoff-grant')).toBe('operator-approval');
+    expect(nextAdmissionStep(configured, 'operator-approval')).toBe(null);
+  });
+
+  it('exposes nothing while the operator has not answered', async () => {
+    const answer = deferred();
+    const approve = vi.fn(() => answer.promise);
+    const { gate, sessionOnMessage, onAccept } = makeGate({ connectionApproval: { approve } });
+    await flush();
+    expect(approve).toHaveBeenCalledTimes(1);
+    gate.onInbound(JSON.stringify({ type: 'submit', prompt: 'p' }));
+    expect(sessionOnMessage).not.toHaveBeenCalled();
+    expect(onAccept).not.toHaveBeenCalled();
+
+    answer.resolve(true);
+    await vi.waitFor(() => expect(onAccept).toHaveBeenCalledTimes(1));
+    // What the peer said while waiting reaches the session only now, in order, then live frames.
+    expect(sessionOnMessage).toHaveBeenCalledTimes(1);
+    gate.onInbound(JSON.stringify({ type: 'get-messages' }));
+    expect(sessionOnMessage.mock.calls.map(([frame]) => JSON.parse(frame as string).type)).toEqual([
+      'submit',
+      'get-messages',
+    ]);
+  });
+
+  it('drops what the peer said while waiting when the operator refuses', async () => {
+    const answer = deferred();
+    const { gate, sessionOnMessage, onReject } = makeGate({
+      connectionApproval: { approve: () => answer.promise },
+    });
+    await flush();
+    gate.onInbound(JSON.stringify({ type: 'submit', prompt: 'p' }));
+    answer.resolve(false);
+    await vi.waitFor(() => expect(onReject).toHaveBeenCalledTimes(1));
+    expect(sessionOnMessage).not.toHaveBeenCalled();
+  });
+
+  it('withdraws the question and admits nothing when the channel closes while the operator decides', async () => {
+    const answer = deferred();
+    let signal: AbortSignal | undefined;
+    const approve = vi.fn((context: IConnectionApprovalContext) => {
+      signal = context.signal;
+      return answer.promise;
+    });
+    const { gate, sessionOnMessage, onAccept, onReject } = makeGate({
+      connectionApproval: { approve },
+    });
+    await flush();
+    gate.onInbound(JSON.stringify({ type: 'get-messages' }));
+    expect(signal?.aborted).toBe(false);
+
+    gate.onChannelClosed();
+    expect(signal?.aborted).toBe(true);
+    expect(onReject).toHaveBeenCalledTimes(1);
+
+    answer.resolve(true);
+    await flush();
+    expect(onAccept).not.toHaveBeenCalled();
+    expect(sessionOnMessage).not.toHaveBeenCalled();
+  });
+
+  it('does not pin an enrolling device whose channel closed while the operator decided', async () => {
+    const cfg = await hostConfig();
+    const answer = deferred();
+    const approve = vi.fn(() => answer.promise);
+    const { gate, onAccept } = makeGate({ reconnect: cfg, connectionApproval: { approve } });
+    gate.onInbound(JSON.stringify({ t: 'pair-nonce', nonce: 'n' }));
+    await flush();
+    const deviceKey = await generateIdentityKeyPair(false);
+    gate.onInbound(
+      JSON.stringify({ t: 'enroll-key', spki: await exportPublicKey(deviceKey.publicKey) }),
+    );
+    await vi.waitFor(() => expect(approve).toHaveBeenCalledTimes(1));
+    gate.onChannelClosed();
+    answer.resolve(true);
+    await flush();
+    expect(cfg.onEnroll).not.toHaveBeenCalled();
+    expect(onAccept).not.toHaveBeenCalled();
+  });
+
+  it('an accepted channel closing is the transport’s drop, not a refusal', async () => {
+    const { gate, onAccept, onReject } = makeGate({
+      connectionApproval: { approve: async () => true },
+    });
+    await vi.waitFor(() => expect(onAccept).toHaveBeenCalledTimes(1));
+    gate.onChannelClosed();
+    expect(onReject).not.toHaveBeenCalled();
+  });
+
+  it('refuses a peer that floods the channel while the operator decides', async () => {
+    const answer = deferred();
+    const { gate, closed, onReject, sessionOnMessage } = makeGate({
+      connectionApproval: { approve: () => answer.promise },
+    });
+    await flush();
+    for (let i = 0; i < 100; i += 1) gate.onInbound(JSON.stringify({ type: 'get-messages' }));
+    expect(onReject).toHaveBeenCalledTimes(1);
+    expect(closed()).toBe(true);
+    answer.resolve(true);
+    await flush();
+    expect(sessionOnMessage).not.toHaveBeenCalled();
+  });
+
+  it('refuses the connection the operator declines: closed, and the session never reached', async () => {
+    const { gate, closed, sessionOnMessage, onAccept, onReject } = makeGate({
+      connectionApproval: { approve: async () => false },
+    });
+    await vi.waitFor(() => expect(onReject).toHaveBeenCalledTimes(1));
+    expect(closed()).toBe(true);
+    gate.onInbound(JSON.stringify({ type: 'submit', prompt: 'p' }));
+    expect(sessionOnMessage).not.toHaveBeenCalled();
+    expect(onAccept).not.toHaveBeenCalled();
+  });
+
+  it('refuses when asking the operator fails', async () => {
+    const { closed, onAccept, onReject } = makeGate({
+      connectionApproval: { approve: () => Promise.reject(new Error('no terminal')) },
+    });
+    await vi.waitFor(() => expect(onReject).toHaveBeenCalledTimes(1));
+    expect(closed()).toBe(true);
+    expect(onAccept).not.toHaveBeenCalled();
+  });
+
+  it('does not accept an answer that arrives after the channel was torn down', async () => {
+    const answer = deferred();
+    const { gate, sessionOnMessage, onAccept } = makeGate({
+      connectionApproval: { approve: () => answer.promise },
+    });
+    await flush();
+    gate.cleanup();
+    answer.resolve(true);
+    await flush();
+    expect(onAccept).not.toHaveBeenCalled();
+    gate.onInbound(JSON.stringify({ type: 'submit', prompt: 'p' }));
+    expect(sessionOnMessage).not.toHaveBeenCalled();
+  });
+});
+
+async function hostConfig(over: Partial<IHostReconnectConfig> = {}): Promise<IHostReconnectConfig> {
+  const hostKeyPair = await generateIdentityKeyPair(true);
+  const hostPublicSpki = await exportPublicKey(hostKeyPair.publicKey);
+  return {
+    hostIdentityId: await deriveIdentityId(hostPublicSpki),
+    hostPublicSpki,
+    hostPrivateKey: hostKeyPair.privateKey,
+    resolveDevicePublicKey: async () => undefined,
+    onEnroll: vi.fn(),
+    ...over,
+  };
+}
+
+describe('operator approval with trusted-device enrollment', () => {
+  async function enrollingGate(approval: IConnectionApproval) {
+    const cfg = await hostConfig();
+    const made = makeGate({ reconnect: cfg, connectionApproval: approval });
+    made.gate.onInbound(JSON.stringify({ t: 'pair-nonce', nonce: 'n' }));
+    await flush();
+    const deviceKey = await generateIdentityKeyPair(false);
+    const deviceSpki = await exportPublicKey(deviceKey.publicKey);
+    made.gate.onInbound(JSON.stringify({ t: 'enroll-key', spki: deviceSpki }));
+    return { ...made, cfg, deviceSpki, deviceId: await deriveIdentityId(deviceSpki) };
+  }
+
+  it('asks about the device that enrolled, and pins it only once the operator allows it', async () => {
+    const approve = vi.fn(async () => true);
+    const { cfg, onAccept, deviceId, deviceSpki } = await enrollingGate({ approve });
+    await vi.waitFor(() => expect(onAccept).toHaveBeenCalledTimes(1));
+    expect(approve).toHaveBeenCalledWith(
+      expect.objectContaining({ deviceId, viaReconnect: false }),
+    );
+    expect(cfg.onEnroll).toHaveBeenCalledWith(deviceId, deviceSpki);
+  });
+
+  it('does not pin a device the operator refuses', async () => {
+    const { cfg, onReject } = await enrollingGate({ approve: async () => false });
+    await vi.waitFor(() => expect(onReject).toHaveBeenCalledTimes(1));
+    expect(cfg.onEnroll).not.toHaveBeenCalled();
+  });
+
+  it('asks again when a trusted device reconnects, naming it', async () => {
+    const keyPair = await generateIdentityKeyPair(false);
+    const spki = await exportPublicKey(keyPair.publicKey);
+    const deviceId = await deriveIdentityId(spki);
+    const publicKey = await importPublicKey(spki);
+    const cfg = await hostConfig({
+      resolveDevicePublicKey: async (id) => (id === deviceId ? publicKey : undefined),
+    });
+    const approve = vi.fn(async () => false);
+    let deviceCtrl!: ReturnType<typeof startDeviceReconnect>;
+    const onAccept = vi.fn();
+    const onReject = vi.fn();
+    const gate = new PairingGate({cryptoContext: testIdentity,
+      channel: {
+        send: (d: string) => deviceCtrl.onFrame(JSON.parse(d) as TReconnectFrame),
+        close: () => {},
+      },
+      session: createTestInteractiveSession(),
+      secret: 's',
+      role: 'initiator',
+      ...FP,
+      reconnect: cfg,
+      connectionApproval: { approve },
+      onAccept,
+      onReject,
+    });
+    deviceCtrl = startDeviceReconnect(testIdentity, {
+      deviceId,
+      hostIdentityId: cfg.hostIdentityId,
+      localFingerprint: FP.remoteFingerprint,
+      remoteFingerprint: FP.localFingerprint,
+      devicePrivateKey: keyPair.privateKey,
+      pinnedHostPublicKey: await importPublicKey(cfg.hostPublicSpki),
+      send: (frame) => gate.onInbound(JSON.stringify(frame)),
+      timeoutMs: 1000,
+    });
+    await deviceCtrl.result;
+    await vi.waitFor(() => expect(onReject).toHaveBeenCalledTimes(1));
+    expect(approve).toHaveBeenCalledWith(expect.objectContaining({ deviceId, viaReconnect: true }));
+    expect(onAccept).not.toHaveBeenCalled();
+  });
+});