Computer use for the Pi coding agent — Windows apps, browsers and desktops through native UI trees, screenshots and real input.
TypeScript accessibilityagent-toolsai-agentbrowser-automationcomputer-usecuadesktop-automationelectronpipi-coding-agentpi-extensionpi-packageplaywrighttypescriptui-automationvisionwebview2windowswindows-automationwsl
test: cover isolated relay authentication and cleanup (LPT-1025)
alexshpunt-clanker[bot]9f51563d656c
diff --git a/test/isolated-session.test.ts b/test/isolated-session.test.tsindex 747c2e1..8603b1a 100644--- a/test/isolated-session.test.ts+++ b/test/isolated-session.test.ts@@ -1,14 +1,23 @@import { mkdir, mkdtemp, readFile, writeFile, rm } from "node:fs/promises";import { tmpdir } from "node:os";import path from "node:path";-import { expect, test } from "vitest";+import { afterEach, expect, test } from "vitest";+import type { SessionRelayKeys } from "../src/session-relay.ts";+import { IsolatedSession } from "../src/isolated-session.ts";import type { SandboxHost } from "../src/sandbox.ts";+const roots: string[] = [];+afterEach(async () => { await Promise.all(roots.splice(0).map(root => rm(root, { recursive: true, force: true }))); });+/** A host where wxc-exec answers each lifecycle phase; `failAt` makes one phase fail. Every script is recorded. */-async function fakeHost(options: { installed?: boolean; failAt?: "provision" | "start" } = {}) {+async function fakeHost(options: { installed?: boolean; failAt?: "provision" | "start"; failForward?: number } = {}) {const root = await mkdtemp(path.join(tmpdir(), "pi-session-test-"));+ roots.push(root);const scripts: string[] = [];+ const relayKeys: SessionRelayKeys[] = [];+ let relayClosed = false;+ const forwarded: number[] = [], closedForwards: number[] = [];const phases: string[] = [];const host: SandboxHost = {async path(value, to) {@@ -29,10 +38,6 @@ async function fakeHost(options: { installed?: boolean; failAt?: "provision" | "}return `{"result":{}}`;}- if (script.includes("host-reverse.ps1")) {- await writeFile(path.join(root, "Local/PiComputerUse/sessions", /sessions\\(is-\w+)/.exec(script)![1], "ports.txt"), "1001 1002 1003 1004 4242\n");- return "";- }if (script.includes("--operation exec")) { phases.push("exec"); return "5151\n"; }return "";},@@ -40,9 +45,17 @@ async function fakeHost(options: { installed?: boolean; failAt?: "provision" | "writeFile: (file, content) => writeFile(file, content),readFile: file => readFile(file, "utf8").catch(() => ""),remove: dir => rm(dir, { recursive: true, force: true }),- forward: async port => ({ port: port + 10_000, close: () => {} }),+ async reverseRelay(_workdir, keys) {+ relayKeys.push(keys);+ return { ports: [1001, 1002, 1003, 1004], close: async () => { relayClosed = true; } };+ },+ async forward(port) {+ forwarded.push(port);+ if (forwarded.length === options.failForward) throw new Error("Forwarding refused");+ return { port: port + 10_000, close: () => { closedForwards.push(port); } };+ },};- return { host, scripts, phases, root };+ return { host, scripts, phases, root, relayKeys, closedForwards, relayClosed: () => relayClosed };}test("a session provisions, starts its driver through the reverse relay, and close removes the agent user", async () => {@@ -52,11 +65,25 @@ test("a session provisions, starts its driver through the reverse relay, and cloexpect(session.endpoint).toMatchObject({ url: "http://127.0.0.1:11001/mcp", identityPort: 11003, domain: "windows-session" });// The driver config inside the session points its relay at the host's session-side ports.const config = JSON.parse(await readFile(path.join(f.root, "Users/A1/Shared/session.json"), "utf8"));- expect(config).toMatchObject({ hostDriverPort: 1002, hostIdentityPort: 1004 });+ expect(config).toMatchObject({ hostDriverPort: 1002, hostIdentityPort: 1004,+ relay: { session: session.ref, key: f.relayKeys[0].sessionKey } });+ expect(config.relay.key).not.toBe(session.endpoint?.relay?.key);+ expect(session.endpoint?.relay).toEqual({ session: session.ref, key: f.relayKeys[0].clientKey });+ expect(JSON.stringify(config)).not.toContain(f.relayKeys[0].clientKey);expect(await readFile(path.join(f.root, "Users/A1/Shared/session-start.ps1"), "utf8")).toContain("--no-overlay");await session.close();expect(f.phases).toEqual(["provision", "start", "exec", "stop", "deprovision"]);- expect(f.scripts.at(-1)).toContain("Stop-Process -Id 4242,5151");+ expect(f.scripts.at(-1)).toContain("Stop-Process -Id 5151");+ expect(f.relayClosed()).toBe(true);+ expect(f.closedForwards).toEqual([1001, 1003]);+});++test("a failed second forward closes the first tunnel and relay before removing the session", async () => {+ const f = await fakeHost({ failForward: 2 });+ await expect(IsolatedSession.open(f.host, "/mnt/c/runtime/cua-driver.exe")).rejects.toBeInstanceOf(Error);+ expect(f.closedForwards).toEqual([1001]);+ expect(f.relayClosed()).toBe(true);+ expect(f.phases).toEqual(["provision", "start", "exec", "stop", "deprovision"]);});test("a machine without MXC refuses before provisioning anything", async () => {diff --git a/test/relay-http.test.ts b/test/relay-http.test.tsnew file mode 100644index 0000000..d104dd0--- /dev/null+++ b/test/relay-http.test.ts@@ -0,0 +1,55 @@+import { createServer, type AddressInfo, type Socket } from "node:net";+import { once } from "node:events";+import { expect, test } from "vitest";+import { SingleConnectionHttpTransport } from "../src/http-transport.ts";++test("closing during authentication cancels the pending HTTP request and releases its socket", async () => {+ let accepted: (socket: Socket) => void;+ const incoming = new Promise<Socket>(resolve => { accepted = resolve; });+ const server = createServer(socket => { socket.on("error", () => {}); accepted(socket); });+ await new Promise<void>(resolve => server.listen(0, "127.0.0.1", resolve));+ const transport = new SingleConnectionHttpTransport(new URL(`http://127.0.0.1:${(server.address() as AddressInfo).port}/mcp`), "private-bearer",+ { session: "cancellation-test", key: "cd".repeat(32) });+ const result = transport.send({ jsonrpc: "2.0", id: 1, method: "initialize" }).then(() => false, () => true);+ const socket = await incoming;+ const closed = once(socket, "close"); socket.resume();+ try {+ await transport.close();+ expect(await result).toBe(true);+ await closed;+ expect(socket.destroyed).toBe(true);+ } finally {+ socket.destroy(); await transport.close();+ await new Promise<void>(resolve => server.close(() => resolve()));+ }+});++test("a false relay cannot receive the driver bearer before proving its identity", async () => {+ const sockets = new Set<Socket>();+ const received: Buffer[] = [];+ const server = createServer(socket => {+ sockets.add(socket);+ socket.on("close", () => sockets.delete(socket));+ socket.on("error", () => {});+ socket.write(JSON.stringify({ version: 1, nonce: "ab".repeat(32) }) + "\n");+ socket.on("data", chunk => {+ received.push(chunk);+ // An unauthenticated OK or made-up server proof must never unlock HTTP.+ socket.end(JSON.stringify({ proof: "00".repeat(32) }) + "\n");+ });+ });+ await new Promise<void>(resolve => server.listen(0, "127.0.0.1", resolve));+ const port = (server.address() as AddressInfo).port;+ const bearer = "private-driver-token-must-not-reach-the-false-peer";+ const transport = new SingleConnectionHttpTransport(new URL(`http://127.0.0.1:${port}/mcp`), bearer,+ { session: "test-session", key: "cd".repeat(32) });+ try {+ await expect(transport.send({ jsonrpc: "2.0", id: 1, method: "initialize", params: {} })).rejects.toBeInstanceOf(Error);+ expect(Buffer.concat(received).toString()).not.toContain(bearer);+ expect(Buffer.concat(received).toString()).not.toContain("Authorization:");+ } finally {+ await transport.close();+ for (const socket of sockets) socket.destroy();+ await new Promise<void>(resolve => server.close(() => resolve()));+ }+});diff --git a/test/session-relay-host.test.ts b/test/session-relay-host.test.tsnew file mode 100644index 0000000..da258dd--- /dev/null+++ b/test/session-relay-host.test.ts@@ -0,0 +1,191 @@+import { spawn, type ChildProcessWithoutNullStreams } from "node:child_process";+import { randomBytes } from "node:crypto";+import { once } from "node:events";+import { mkdtemp, readFile, readdir, rm } from "node:fs/promises";+import { connect, type Socket } from "node:net";+import { tmpdir } from "node:os";+import path from "node:path";+import { expect, test } from "vitest";+import { connectRelay } from "../src/relay-auth.ts";+import { localRunner, type CommandRunner } from "../src/runner.ts";+import { startSessionRelay } from "../src/session-relay-host.ts";++const keys = () => ({ session: "worker-test", clientKey: randomBytes(32).toString("hex"), sessionKey: randomBytes(32).toString("hex") });+const unreachable = (port: number) => new Promise<boolean>(resolve => {+ const socket = connect({ port, host: "127.0.0.1" });+ socket.once("connect", () => { socket.destroy(); resolve(false); });+ socket.once("error", () => { socket.destroy(); resolve(true); });+});++async function fixture(script?: string) {+ const root = await mkdtemp(path.join(tmpdir(), "pi-relay-worker-"));+ const children: ChildProcessWithoutNullStreams[] = [];+ const invocations: { file: string; args: readonly string[]; env?: Record<string, string> }[] = [];+ const local = localRunner();+ const runner: CommandRunner = {+ ...local, ssh: "fixture",+ spawn(file, args, env) {+ invocations.push({ file, args, env });+ const child = script === undefined ? local.spawn(file, args, env) : spawn(process.execPath, ["-e", script], { stdio: "pipe" });+ children.push(child); return child;+ },+ };+ const cleanup = async () => {+ for (const child of children) if (child.exitCode === null && child.signalCode === null) {+ const closed = once(child, "close").catch(() => {}); child.kill(); await closed;+ }+ await rm(root, { recursive: true, force: true });+ };+ return { root, runner, children, invocations, cleanup };+}++test("local relay uses owned in-process listeners and close releases all ports", async () => {+ const k = keys(); const relay = await startSessionRelay(localRunner(), "unused", k);+ const sockets: Socket[] = [];+ try {+ const client = await connectRelay(relay.ports[0], { session: k.session, key: k.clientKey }, { channel: "driver", role: "client" }); sockets.push(client);+ const session = await connectRelay(relay.ports[1], { session: k.session, key: k.sessionKey }, { channel: "driver", role: "session" }); sockets.push(session);+ const reply = once(client, "data"); client.resume(); session.write("owned-response");+ expect(String((await reply)[0])).toBe("owned-response");+ await relay.close();+ expect(await Promise.all(relay.ports.map(unreachable))).toEqual([true, true, true, true]);+ } finally { sockets.forEach(s => s.destroy()); await relay.close(); }+});++test("remote worker receives credentials only on stdin and EOF closes listeners and process", async () => {+ const f = await fixture(); const k = keys();+ try {+ const relay = await startSessionRelay(f.runner, f.root, k);+ const session = await connectRelay(relay.ports[3], { session: k.session, key: k.sessionKey }, { channel: "identity", role: "session" });+ try {+ expect(f.invocations).toHaveLength(1);+ expect(JSON.stringify(f.invocations)).not.toContain(k.clientKey);+ expect(JSON.stringify(f.invocations)).not.toContain(k.sessionKey);+ for (const name of await readdir(f.root)) {+ const source = await readFile(path.join(f.root, name), "utf8");+ expect(source).not.toContain(k.clientKey); expect(source).not.toContain(k.sessionKey);+ }+ await relay.close();+ expect(f.children[0].exitCode).toBe(0);+ expect(await Promise.all(relay.ports.map(unreachable))).toEqual([true, true, true, true]);+ } finally { session.destroy(); await relay.close(); }+ } finally { await f.cleanup(); }+});++test("failed startup waits for every started worker transfer before cleanup can proceed", async () => {+ const f = await fixture();+ const transfers: { resolve(value: string): void; reject(error: Error): void }[] = [];+ let allStarted: () => void;+ const started = new Promise<void>(resolve => { allStarted = resolve; });+ const original = f.runner.run;+ f.runner.run = (file, args, options) => file !== "dd" ? original(file, args, options) : new Promise<string>((resolve, reject) => {+ transfers.push({ resolve, reject });+ if (transfers.length === 3) allStarted();+ });+ const outcome = startSessionRelay(f.runner, f.root, keys()).then(() => "ready", () => "rejected");+ try {+ await started;+ transfers[0].reject(new Error("Transfer fixture failure"));+ const state = await Promise.race([outcome, new Promise<string>(resolve => setTimeout(() => resolve("waiting"), 20))]);+ expect(state).toBe("waiting");+ transfers[1].resolve(""); transfers[2].resolve("");+ expect(await outcome).toBe("rejected");+ expect(f.children).toHaveLength(0);+ } finally {+ transfers.forEach(transfer => transfer.resolve(""));+ await outcome; await f.cleanup();+ }+});++test("an already cancelled startup launches no child or listeners", async () => {+ const f = await fixture(); const abort = new AbortController(); abort.abort();+ try {+ await expect(startSessionRelay(f.runner, f.root, keys(), abort.signal)).rejects.toBeInstanceOf(Error);+ expect(f.children).toHaveLength(0);+ expect(await readdir(f.root)).toEqual([]);+ } finally { await f.cleanup(); }+});++test("cancellation while the worker starts closes stdin and awaits process exit", async () => {+ const f = await fixture("process.stdin.resume(); process.stdin.on('end',()=>process.exit(0)); process.stdin.on('data',()=>{});");+ const abort = new AbortController();+ try {+ const opening = startSessionRelay(f.runner, f.root, keys(), abort.signal);+ // The runner is the real spawn boundary, so cancellation always occurs after the child exists.+ const waitSpawn = f.runner.spawn;+ f.runner.spawn = (...args) => { const child = waitSpawn(...args); queueMicrotask(() => abort.abort()); return child; };+ await expect(opening).rejects.toBeInstanceOf(Error);+ expect(f.children).toHaveLength(1);+ expect(f.children[0].exitCode).toBe(0);+ } finally { await f.cleanup(); }+});++test("EOF during asynchronous worker startup closes listeners that finish opening afterward", async () => {+ const f = await fixture(); const k = keys();+ let child: ChildProcessWithoutNullStreams | undefined;+ try {+ // Copy the real worker through the production launcher first, then close that owned instance.+ const prepared = await startSessionRelay(f.runner, f.root, k); await prepared.close();+ const preload = `import net from 'node:net'; const listen = net.Server.prototype.listen; net.Server.prototype.listen = function(...args) { setTimeout(() => listen.apply(this, args), 25); return this; };`;+ child = spawn(process.execPath, ["--experimental-strip-types", `--import=data:text/javascript,${encodeURIComponent(preload)}`, path.join(f.root, "session-relay-worker.ts")], { stdio: "pipe" });+ let output = ""; child.stdout.on("data", chunk => { output += chunk.toString(); }); child.stderr.resume();+ const closed = once(child, "close");+ child.stdin.end(JSON.stringify(k) + "\n");+ const [code, signal] = await closed;+ expect(code).toBe(0); expect(signal).toBeNull();+ expect(output).toBe("");+ } finally {+ if (child && child.exitCode === null && child.signalCode === null) { const closed = once(child, "close"); child.kill(); await closed; }+ await f.cleanup();+ }+});++test("malformed credentials never produce readiness and the real worker exits", async () => {+ const f = await fixture();+ try {+ await expect(startSessionRelay(f.runner, f.root, { ...keys(), clientKey: "not-a-key" })).rejects.toBeInstanceOf(Error);+ expect(f.children).toHaveLength(1);+ expect(f.children[0].exitCode).toBe(1);+ } finally { await f.cleanup(); }+});++test("a missing worker executable is rejected without leaving a live child", async () => {+ const f = await fixture();+ f.runner.spawn = () => {+ const child = spawn(path.join(f.root, "missing-node"), [], { stdio: "pipe" });+ f.children.push(child); return child;+ };+ try {+ await expect(startSessionRelay(f.runner, f.root, keys())).rejects.toBeInstanceOf(Error);+ expect(f.children).toHaveLength(1);+ expect(f.children[0].exitCode).not.toBeNull();+ } finally { await f.cleanup(); }+});++test("a broken worker input pipe rejects startup and still waits for EOF cleanup", async () => {+ const f = await fixture();+ const original = f.runner.spawn;+ f.runner.spawn = (...args) => {+ const child = original(...args);+ queueMicrotask(() => child.stdin.destroy(new Error("fixture pipe error")));+ return child;+ };+ try {+ await expect(startSessionRelay(f.runner, f.root, keys())).rejects.toBeInstanceOf(Error);+ expect(f.children).toHaveLength(1);+ expect(f.children[0].exitCode).toBe(0);+ } finally { await f.cleanup(); }+});++test.each([+ "process.stdout.write('not-json\\n'); process.stdin.resume();",+ "process.stdout.write('x'.repeat(2048)); process.stdin.resume();",+ "process.stdout.write(JSON.stringify({ports:[1,2]})+'\\n'); process.stdin.resume();",+ "process.stdin.resume(); process.stdin.once('data',()=>process.exit(7));",+])("invalid startup output or early worker failure is rejected and reaped (%#)", async script => {+ const f = await fixture(script);+ try {+ await expect(startSessionRelay(f.runner, f.root, keys())).rejects.toBeInstanceOf(Error);+ expect(f.children[0].exitCode).not.toBeNull();+ } finally { await f.cleanup(); }+});diff --git a/test/session-relay.test.ts b/test/session-relay.test.tsnew file mode 100644index 0000000..66a16b7--- /dev/null+++ b/test/session-relay.test.ts@@ -0,0 +1,162 @@+import { createHmac, randomBytes } from "node:crypto";+import { createServer as httpServer } from "node:http";+import { once } from "node:events";+import { connect, createServer, type AddressInfo, type Socket } from "node:net";+import { setTimeout as delay } from "node:timers/promises";+import { expect, test } from "vitest";+import { connectRelay } from "../src/relay-auth.ts";+import { createSessionRelay } from "../src/session-relay.ts";+import { SingleConnectionHttpTransport } from "../src/http-transport.ts";++const keys = () => ({ session: "test-session", clientKey: randomBytes(32).toString("hex"), sessionKey: randomBytes(32).toString("hex") });+const proofContext = (auth: { session: string; key: string }, side: string, channel: string, role: string, serverNonce: unknown, nonce: unknown) =>+ createHmac("sha256", Buffer.from(auth.key, "hex")).update(JSON.stringify(["pi-relay", 1, side, auth.session, channel, role, serverNonce, nonce])).digest("hex");+const line = (socket: Socket): Promise<Record<string, unknown>> => new Promise((resolve, reject) => {+ let text = "";+ const data = (chunk: Buffer) => { text += chunk.toString(); if (text.includes("\n")) { socket.pause(); socket.off("data", data); resolve(JSON.parse(text.split("\n")[0])); } };+ socket.once("error", reject); socket.on("data", data); socket.resume();+});++test("a foreign reverse endpoint cannot enter pairing or receive driver credentials", async () => {+ const k = keys();+ const relay = await createSessionRelay(k, { authenticationTimeoutMs: 100 });+ const attacker = connect(relay.ports[1], "127.0.0.1");+ const stolen: Buffer[] = [];+ attacker.on("data", c => stolen.push(c)); attacker.on("error", () => {});+ const dropped = once(attacker, "close");+ const transport = new SingleConnectionHttpTransport(new URL(`http://127.0.0.1:${relay.ports[0]}/mcp`), "secret-bearer",+ { session: k.session, key: k.clientKey });+ let legitimate: Socket | undefined;+ try {+ const response = transport.send({ jsonrpc: "2.0", id: 1, method: "initialize" });+ await dropped;+ legitimate = await connectRelay(relay.ports[1], { session: k.session, key: k.sessionKey }, { channel: "driver", role: "session" });+ let request = "";+ legitimate.on("data", chunk => {+ request += chunk.toString();+ if (!request.includes("secret-bearer")) return;+ const body = JSON.stringify({ jsonrpc: "2.0", id: 1, result: {} });+ legitimate!.write(`HTTP/1.1 200 OK\r\nContent-Type: application/json\r\nContent-Length: ${Buffer.byteLength(body)}\r\n\r\n${body}`);+ });+ legitimate.resume();+ await response;+ expect(request).toContain("Authorization: Bearer secret-bearer");+ expect(Buffer.concat(stolen).toString()).not.toContain("secret-bearer");+ expect(Buffer.concat(stolen).toString()).not.toContain("POST /mcp");+ } finally { attacker.destroy(); legitimate?.destroy(); await transport.close(); await relay.close(); }+});++test("successive driver requests keep the same authenticated native TCP connection", async () => {+ let accepted = 0;+ const native = httpServer((request, response) => {+ let body = "";+ request.on("data", chunk => { body += String(chunk); });+ request.on("end", () => {+ const message = JSON.parse(body);+ response.writeHead(200, { "Content-Type": "application/json" });+ response.end(JSON.stringify({ jsonrpc: "2.0", id: message.id, result: {} }));+ });+ });+ native.on("connection", () => { accepted++; });+ await new Promise<void>(resolve => native.listen(0, "127.0.0.1", resolve));+ const k = keys(), relay = await createSessionRelay(k);+ const remote = await connectRelay(relay.ports[1], { session: k.session, key: k.sessionKey }, { channel: "driver", role: "session" });+ const local = connect((native.address() as AddressInfo).port, "127.0.0.1");+ remote.pipe(local); local.pipe(remote);+ const transport = new SingleConnectionHttpTransport(new URL(`http://127.0.0.1:${relay.ports[0]}/mcp`), "driver-token",+ { session: k.session, key: k.clientKey });+ const replies: unknown[] = []; transport.onmessage = message => { replies.push(message); };+ try {+ for (const id of [1, 2]) await transport.send({ jsonrpc: "2.0", id, method: "test" });+ expect(replies).toEqual([{ jsonrpc: "2.0", id: 1, result: {} }, { jsonrpc: "2.0", id: 2, result: {} }]);+ expect(accepted).toBe(1);+ } finally {+ await transport.close(); remote.destroy(); local.destroy(); await relay.close();+ native.closeAllConnections(); await new Promise<void>(resolve => native.close(() => resolve()));+ }+});++test("a valid key cannot substitute a different session, role or channel", async () => {+ const k = keys(); const relay = await createSessionRelay(k);+ try {+ for (const [auth, context] of [+ [{ session: k.session, key: k.sessionKey }, { channel: "driver", role: "client" }],+ [{ session: "other-session", key: k.clientKey }, { channel: "driver", role: "client" }],+ [{ session: k.session, key: k.clientKey }, { channel: "identity", role: "client" }],+ [{ session: k.session, key: k.clientKey }, { channel: "driver", role: "session" }],+ ] as const) {+ await expect(connectRelay(relay.ports[0], auth, context)).rejects.toBeInstanceOf(Error);+ }+ } finally { await relay.close(); }+});++test("a server proof coalesced with application bytes preserves every payload byte", async () => {+ const auth = { session: "coalesced-test", key: "ef".repeat(32) };+ const sockets: Socket[] = [];+ const server = createServer(socket => {+ sockets.push(socket); socket.on("error", () => {});+ const nonce = "ab".repeat(32);+ socket.write(JSON.stringify({ version: 1, nonce }) + "\n");+ void line(socket).then(frame => {+ const mac = proofContext(auth, "server", "identity", "client", nonce, frame.nonce);+ socket.write(JSON.stringify({ proof: mac }) + "\n" + "identity-payload\n");+ });+ });+ await new Promise<void>(resolve => server.listen(0, "127.0.0.1", resolve));+ try {+ const peer = await connectRelay((server.address() as AddressInfo).port, auth, { channel: "identity", role: "client" });+ sockets.push(peer);+ const data = once(peer, "data"); peer.resume();+ expect(String((await data)[0])).toBe("identity-payload\n");+ } finally { sockets.forEach(s => s.destroy()); await new Promise<void>(resolve => server.close(() => resolve())); }+});++test("oversized unauthenticated frames are dropped without entering a pairing queue", async () => {+ const k = keys(); const relay = await createSessionRelay(k);+ const attacker = connect(relay.ports[1], "127.0.0.1"); attacker.on("error", () => {});+ try {+ await line(attacker);+ const closed = once(attacker, "close");+ attacker.write("x".repeat(513)); attacker.resume();+ await closed;+ expect(attacker.destroyed).toBe(true);+ } finally { attacker.destroy(); await relay.close(); }+});++test("proofs cannot be replayed on another connection, channel or role", async () => {+ const k = keys(); const relay = await createSessionRelay(k);+ const sockets: Socket[] = [];+ try {+ const first = connect(relay.ports[0], "127.0.0.1"); sockets.push(first);+ const challenge = await line(first);+ const nonce = randomBytes(32).toString("hex");+ const proof = createHmac("sha256", Buffer.from(k.clientKey, "hex"))+ .update(JSON.stringify(["pi-relay", 1, "client", k.session, "driver", "client", challenge.nonce, nonce])).digest("hex");+ const frame = { version: 1, session: k.session, channel: "driver", role: "client", nonce, proof };+ const serverProof = line(first); first.write(JSON.stringify(frame) + "\n");+ expect(await serverProof).toHaveProperty("proof");+ for (const port of [relay.ports[0], relay.ports[1], relay.ports[2]]) {+ const replay = connect(port, "127.0.0.1"); replay.on("error", () => {}); sockets.push(replay);+ await line(replay);+ const closed = once(replay, "close"); replay.write(JSON.stringify(frame) + "\n"); replay.resume();+ await closed;+ expect(replay.destroyed).toBe(true);+ }+ } finally { sockets.forEach(s => s.destroy()); await relay.close(); }+});++test("an idle driver handshake does not block identity and authenticated peers survive idle time", async () => {+ const k = keys(); const relay = await createSessionRelay(k, { authenticationTimeoutMs: 80 });+ const idle = connect(relay.ports[1], "127.0.0.1"); idle.on("error", () => {});+ const sockets: Socket[] = [idle];+ try {+ const session = await connectRelay(relay.ports[3], { session: k.session, key: k.sessionKey }, { channel: "identity", role: "session" }); sockets.push(session);+ const client = await connectRelay(relay.ports[2], { session: k.session, key: k.clientKey }, { channel: "identity", role: "client" }); sockets.push(client);+ await delay(180);+ const reply = once(client, "data"); client.resume();+ session.write("persistent-identity-response\n"); session.resume();+ expect(String((await reply)[0])).toBe("persistent-identity-response\n");+ await relay.close();+ await expect(connectRelay(relay.ports[0], { session: k.session, key: k.clientKey }, { channel: "driver", role: "client" })).rejects.toBeInstanceOf(Error);+ } finally { sockets.forEach(s => s.destroy()); await relay.close(); }+});