@xenon-device-management/xenon 2.0.0 → 2.2.0

package/lib/src/device-utils.js

@@ -66,6 +66,7 @@ exports.unblockCandidateDevices = unblockCandidateDevices;
 exports.releaseBlockedDevices = releaseBlockedDevices;
 exports.setupCronReleaseBlockedDevices = setupCronReleaseBlockedDevices;
 exports.setupCronUpdateDeviceList = setupCronUpdateDeviceList;
+exports.unregisterNodeFromHub = unregisterNodeFromHub;
 exports.setupCronLocalDiscovery = setupCronLocalDiscovery;
 exports.cleanPendingSessions = cleanPendingSessions;
 exports.setupCronCleanPendingSessions = setupCronCleanPendingSessions;
@@ -82,6 +83,8 @@ const async_wait_until_1 = __importDefault(require("async-wait-until"));
 const typedi_1 = require("typedi");
 const device_managers_1 = require("./device-managers");
 const device_service_1 = require("./data-service/device-service");
+const deviceClaims_1 = require("./data-service/deviceClaims");
+const PluginContext_1 = require("./PluginContext");
 const logger_1 = __importDefault(require("./logger"));
 const Platform_1 = __importDefault(require("./enums/Platform"));
 const lodash_1 = __importDefault(require("lodash"));
@@ -91,6 +94,7 @@ const AndroidDeviceManager_1 = __importDefault(require("./device-managers/Androi
 const IOSDeviceManager_1 = __importDefault(require("./device-managers/IOSDeviceManager"));
 const IOSDiscoveryService_1 = require("./device-managers/ios/IOSDiscoveryService");
 const NodeDevices_1 = __importDefault(require("./device-managers/NodeDevices"));
+const localDeviceHosts_1 = require("./device-managers/localDeviceHosts");
 const config_1 = require("./config");
 const device_store_1 = require("./data-service/device-store");
 const leaseSessionCaps_1 = require("./services/lease/leaseSessionCaps");
@@ -204,8 +208,9 @@ function allocateDeviceForSession(capability_1, deviceTimeOutMs_1, deviceQueryIn
                 const availableCandidate = matchingDevices.find((d) => !(0, device_service_1.isDeviceReserved)(d));
                 if (availableCandidate) {
                     // Principal Intelligence: Multi-node consistent locking
-                    // Attempt to atomically claim this specific device
-                    device = yield store.findAndLockDevice(Object.assign(Object.assign({}, filters), { udid: [availableCandidate.udid] }));
+                    // Attempt to atomically claim this specific device: busy, with a
+                    // pending claim for the session being created (deviceClaims.ts).
+                    device = yield store.findAndLockDevice(Object.assign(Object.assign({}, filters), { udid: [availableCandidate.udid] }), { claim: true });
                     return device !== null;
                 }
                 logger_1.default.info(`Waiting for free device. Filter: ${JSON.stringify(filters)}}`);
@@ -245,7 +250,7 @@ function allocateDeviceForSession(capability_1, deviceTimeOutMs_1, deviceQueryIn
                     const isReady = yield manager.readyForSession(lockedDevice);
                     if (!isReady) {
                         logger_1.default.error(`❌ [Allocation] Device ${lockedDevice.udid} failed pre-session health check. Unblocking.`);
-                        yield (0, device_service_1.unblockDevice)(lockedDevice.udid, lockedDevice.host);
+                        yield (0, device_service_1.releasePendingClaim)(lockedDevice);
                         throw new Error(`Device ${lockedDevice.udid} is unhealthy and could not be autonomously recovered.`);
                     }
                 }
@@ -468,17 +473,20 @@ function getBusyDevicesCount() {
         }).length;
     });
 }
-function updateDeviceList(host, hubArgument, tlsRejectUnauthorized) {
+function updateDeviceList(local, hubArgument, tlsRejectUnauthorized) {
     return __awaiter(this, void 0, void 0, function* () {
         const allExistingDevices = yield (0, device_service_1.getAllDevices)();
         const devices = yield getDeviceManager().getDevices(allExistingDevices);
         // first thing first. Update device list in local list
-        yield (0, device_service_1.syncDiscoveredDevices)(devices, allExistingDevices, host);
-        // Prune any devices that are in our local DB for this host but NO LONGER discovered.
-        // This automatically cleans up disconnected Android devices safely, or filtered
-        // iOS simulators (e.g. when booted-simulators is turned on and a simulator shuts down)
+        yield (0, device_service_1.syncDiscoveredDevices)(devices, allExistingDevices, local.origin);
+        // Prune this server's own phones that discovery no longer reports: an
+        // unplugged Android phone, or a simulator filtered out (e.g. booted-simulators
+        // is on and it shut down). Only its own (isOwnDevice: by nodeId, or else by
+        // exact host): a hub keeps its nodes' phones in the same table, and a node
+        // on the same machine differs from the hub only by port.
+        const nodeId = typedi_1.Container.get(PluginContext_1.PluginContext).nodeId;
         const discoveredUdids = new Set(devices.map((d) => d.udid));
-        const staleLocalDevices = allExistingDevices.filter((d) => (d.host === host || d.host.includes(`//${host}:`) || d.host.includes(`//${host}/`)) && !discoveredUdids.has(d.udid));
+        const staleLocalDevices = allExistingDevices.filter((d) => (0, localDeviceHosts_1.isOwnDevice)(local, nodeId, d) && !discoveredUdids.has(d.udid));
         if (staleLocalDevices.length > 0) {
             logger_1.default.info(`Removing ${staleLocalDevices.length} stale devices/simulators no longer discovered on this host.`);
             yield (0, device_service_1.removeDevice)(staleLocalDevices.map((d) => ({ udid: d.udid, host: d.host })));
@@ -519,23 +527,25 @@ function refreshSimulatorState(pluginArgs, hostPort) {
         }), 10000);
     });
 }
-function setupCronCheckStaleDevices(intervalMs, currentHost, tlsRejectUnauthorized) {
+function setupCronCheckStaleDevices(intervalMs, local, tlsRejectUnauthorized) {
     return __awaiter(this, void 0, void 0, function* () {
         setInterval(() => __awaiter(this, void 0, void 0, function* () {
-            yield removeStaleDevices(currentHost, tlsRejectUnauthorized);
+            yield removeStaleDevices(local, tlsRejectUnauthorized);
         }), intervalMs);
     });
 }
 /**
  * Remove devices where the host is not alive nor defined.
- * @param currentHost current host ip address
+ * @param local the hosts this server files its own phones under
  */
-function removeStaleDevices(currentHost, tlsRejectUnauthorized) {
+function removeStaleDevices(local, tlsRejectUnauthorized) {
     return __awaiter(this, void 0, void 0, function* () {
         const allDevices = yield (0, device_service_1.getAllDevices)();
+        const nodeId = typedi_1.Container.get(PluginContext_1.PluginContext).nodeId;
         const nodeDevices = allDevices.filter((device) => {
-            // devices that's not from this node ip address
-            return device.host !== undefined && !device.host.includes(currentHost);
+            // Phones another server drives: by nodeId, or else by exact host (a node
+            // on this machine shares the IP, and an IP can be a prefix of another's).
+            return device.host !== undefined && !(0, localDeviceHosts_1.isOwnDevice)(local, nodeId, device);
         });
         const devicesWithNoHost = nodeDevices.filter((device) => {
             return device.host === undefined;
@@ -558,8 +568,14 @@ function removeStaleDevices(currentHost, tlsRejectUnauthorized) {
         const allAliveHosts = [...aliveHosts, ...aliveCloudHosts]
             .filter((item) => item.status === 'fulfilled' && item.value.alive)
             .map((item) => item.value.host);
+        // A node's phones carry its nodeId, and live as long as the node does:
+        // while any host of that node answers, its phone filed under a host that
+        // can't be probed (an iPhone under a bare remoteMachineProxyIP) stays.
+        const liveNodeIds = new Set(nodeDevices
+            .filter((device) => device.nodeId && allAliveHosts.includes(device.host))
+            .map((device) => device.nodeId));
         // stale devices are devices that's not alive
-        const staleDevices = nodeDevices.filter((device) => !allAliveHosts.includes(device.host));
+        const staleDevices = nodeDevices.filter((device) => !allAliveHosts.includes(device.host) && !(device.nodeId && liveNodeIds.has(device.nodeId)));
         yield (0, device_service_1.removeDevice)(staleDevices.map((device) => ({ udid: device.udid, host: device.host })));
         if (staleDevices.length > 0) {
             logger_1.default.debug(`Removing device with udid(s): ${staleDevices
@@ -586,14 +602,26 @@ function unblockCandidateDevices() {
 }
 function releaseBlockedDevices(newCommandTimeout) {
     return __awaiter(this, void 0, void 0, function* () {
+        var _a;
         const busyDevices = yield unblockCandidateDevices();
         logger_1.default.debug(`Found ${busyDevices.length} device candidates to be released`);
-        busyDevices.forEach(function (device) {
+        for (const device of busyDevices) {
             // need to keep this to make typescript happy. good thing tho.
             if (device.lastCmdExecutedAt == undefined) {
-                return;
+                continue;
             }
             const currentEpoch = new Date().getTime();
+            // A claim whose session is still being created is not idle: a first
+            // driver install can outlast the new-command timeout. It has its own
+            // timeout, for a create that never finished (deviceClaims.ts).
+            if ((0, deviceClaims_1.isPendingClaim)(device)) {
+                if ((0, deviceClaims_1.pendingClaimExpired)(device, currentEpoch)) {
+                    logger_1.default.warn(`Releasing ${device.udid} at ${device.host}: its session was never created ` +
+                        `(claimed ${Math.round((currentEpoch - device.claimedAt) / 1000)} seconds ago)`);
+                    yield (0, device_service_1.releasePendingClaim)(device).catch((err) => logger_1.default.error(`Unable to release ${device.udid}: ${err}`));
+                }
+                continue;
+            }
             const timeoutSeconds = device.newCommandTimeout != undefined ? device.newCommandTimeout : newCommandTimeout;
             const timeSinceLastCmdExecuted = (currentEpoch - device.lastCmdExecutedAt) / 1000;
             if (timeSinceLastCmdExecuted > timeoutSeconds) {
@@ -612,9 +640,14 @@ function releaseBlockedDevices(newCommandTimeout) {
                     });
                     logger_1.default.warn(`🕒 Session ${sessionId} timed out on device ${device.udid}`);
                 }
-                (0, device_service_1.unblockDevice)(device.udid, device.host);
+                // Keyed on the session read here, so a release that loses the race to
+                // the session's own end (and the phone's next claim) frees nothing.
+                const claimant = (_a = device.claimSessionId) !== null && _a !== void 0 ? _a : device.session_id;
+                yield (claimant
+                    ? (0, device_service_1.releaseSessionDevice)(device.udid, device.host, claimant)
+                    : (0, device_service_1.unblockDevice)(device.udid, device.host)).catch((err) => logger_1.default.error(`Unable to release ${device.udid}: ${err}`));
             }
-        });
+        }
     });
 }
 function setupCronReleaseBlockedDevices(intervalMs, newCommandTimeoutSec) {
@@ -628,29 +661,50 @@ function setupCronReleaseBlockedDevices(intervalMs, newCommandTimeoutSec) {
         }), intervalMs);
     });
 }
-function setupCronUpdateDeviceList(host, hubArgument, intervalMs, tlsRejectUnauthorized) {
+function setupCronUpdateDeviceList(local, hubArgument, intervalMs, tlsRejectUnauthorized) {
     return __awaiter(this, void 0, void 0, function* () {
         if (cronTimerToUpdateDevices) {
             clearInterval(cronTimerToUpdateDevices);
         }
         logger_1.default.info(`This node will send device list update to the hub (${hubArgument}) every ${intervalMs} ms`);
         cronTimerToUpdateDevices = setInterval(() => __awaiter(this, void 0, void 0, function* () {
-            yield updateDeviceList(host, hubArgument, tlsRejectUnauthorized);
+            yield updateDeviceList(local, hubArgument, tlsRejectUnauthorized);
         }), intervalMs);
     });
 }
+/**
+ * Tells the hub this node is leaving, once for each host its phones are filed
+ * under, with the node's id: the hub drops the phones this node reported
+ * (by `nodeId`, else by exact host) and never another server's. Only URL
+ * hosts are sent: a hub before that rule matched anything that isn't a URL as
+ * a substring, which is how the node's bare IP also took the hub's own phones
+ * on the same machine.
+ */
+function unregisterNodeFromHub(hubArgument, local, tlsRejectUnauthorized, nodeId) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const hub = new NodeDevices_1.default(hubArgument, {
+            tlsRejectUnauthorized,
+            hubAccessKey: config_1.config.hubAccessKey,
+            hubToken: config_1.config.hubToken,
+        });
+        for (const host of local.hosts) {
+            if (/^https?:\/\//.test(host))
+                yield hub.unRegisterNode(host, nodeId);
+        }
+    });
+}
 /**
  * Principal discovery: Periodically poll for local devices to prune stales/offlines.
  * Critical for standalone Hubs where setupCronUpdateDeviceList isn't called.
  */
-function setupCronLocalDiscovery(host, intervalMs) {
+function setupCronLocalDiscovery(local, intervalMs) {
     return __awaiter(this, void 0, void 0, function* () {
         if (timer) {
             clearInterval(timer);
         }
         logger_1.default.info(`Local device discovery poll started every ${intervalMs} ms`);
         timer = setInterval(() => __awaiter(this, void 0, void 0, function* () {
-            yield updateDeviceList(host);
+            yield updateDeviceList(local);
         }), intervalMs);
     });
 }

package/lib/src/gateway/createHandoff.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CreateHandoff = void 0;
+exports.runWithCreateHandoff = runWithCreateHandoff;
+exports.currentCreateHandoff = currentCreateHandoff;
+const async_hooks_1 = require("async_hooks");
+/**
+ * The allocation the session gateway made for one `POST <basePath>/session`,
+ * on its way to the plugin.
+ *
+ * For a phone this server drives, the gateway allocates in front of Appium's
+ * route, then calls `next()` inside this request's async context. Appium's
+ * route, its umbrella driver and every plugin before Xenon's run inside that
+ * context, so XenonPlugin.createSession finds the allocation here and does not
+ * allocate a second phone (sessionCreate.ts).
+ *
+ * It is handed over at most once. Whatever happens first wins:
+ * - the plugin takes it, and from then on releasing the phone on failure is
+ *   the plugin's job (SessionLifecycleService.completeLocalSession);
+ * - or the request ends without the plugin taking it (Appium or another
+ *   plugin refused the create first, or the client went away), and the
+ *   gateway abandons it, which gives the phone back. A plugin that arrives
+ *   after that finds it closed.
+ *
+ * Both happen on the event loop, so there is no interleaving between them.
+ * Once taken or given back it keeps no reference to the allocation: things
+ * the driver starts during the create (sockets, timers) keep this context,
+ * and with it this object, for as long as they live.
+ */
+class CreateHandoff {
+    constructor(allocation, giveBack) {
+        this.allocation = allocation;
+        this.giveBack = giveBack;
+        this.state = 'waiting';
+    }
+    /** The allocation, once. Throws when it was taken already or given back. */
+    take() {
+        if (this.state === 'taken') {
+            throw new Error("This request's device allocation was already used by a createSession.");
+        }
+        if (this.state === 'closed') {
+            throw new Error('The request was closed before its session was created; its device was given back.');
+        }
+        this.state = 'taken';
+        const allocation = this.allocation;
+        this.allocation = undefined;
+        return allocation;
+    }
+    /** Give the allocation back if nobody took it. Safe to call more than once. */
+    abandon() {
+        if (this.state !== 'waiting')
+            return;
+        this.state = 'closed';
+        const allocation = this.allocation;
+        this.allocation = undefined;
+        try {
+            this.giveBack(allocation);
+        }
+        catch (_a) {
+            /* the giver logs its own failures; a throw here would reach the socket */
+        }
+    }
+}
+exports.CreateHandoff = CreateHandoff;
+const handoffs = new async_hooks_1.AsyncLocalStorage();
+/** Run `fn` (the rest of the request) with this handoff as its context. */
+function runWithCreateHandoff(handoff, fn) {
+    return handoffs.run(handoff, fn);
+}
+/** The handoff of the create request this code runs for, if the gateway made one. */
+function currentCreateHandoff() {
+    return handoffs.getStore();
+}

package/lib/src/gateway/defaultGateway.js

@@ -0,0 +1,80 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hubGatewayOptions = hubGatewayOptions;
+exports.nodeGatewayOptions = nodeGatewayOptions;
+exports.gatewayOptionsFor = gatewayOptionsFor;
+const typedi_1 = require("typedi");
+const base_driver_1 = require("@appium/base-driver");
+const logger_1 = __importDefault(require("../logger"));
+const prisma_1 = require("../prisma");
+const appiumBasePath_1 = require("../app/appiumBasePath");
+const localDeviceHosts_1 = require("../device-managers/localDeviceHosts");
+const SessionManager_1 = require("../sessions/SessionManager");
+const SessionLifecycleService_1 = require("../services/SessionLifecycleService");
+const NetworkConditioningService_1 = require("../services/NetworkConditioningService");
+const event_manager_1 = require("../dashboard/event-manager");
+const device_service_1 = require("../data-service/device-service");
+const hubSessionToken_1 = require("./hubSessionToken");
+const nodeWebDriverUrl_1 = require("./nodeWebDriverUrl");
+const sessionLocator_1 = require("./sessionLocator");
+const sessionGateway_1 = require("./sessionGateway");
+/**
+ * The session gateway as a Xenon server runs it: the production wiring of
+ * sessionGateway.ts, sessionCreate.ts, sessionLocator.ts and hubSessionToken.ts.
+ */
+const latencyOf = (sessionId) => typedi_1.Container.get(NetworkConditioningService_1.NetworkConditioningService).getLatency(sessionId);
+/** `POST <basePath>/session` in the gateway, with the server's SessionLifecycleService. */
+const createWith = (hubGrants) => ({
+    lifecycle: () => typedi_1.Container.get(SessionLifecycleService_1.SessionLifecycleService),
+    hubGrants,
+    logger: logger_1.default.scope('SessionGateway'),
+});
+const dashboardHooks = {
+    before: (sessionId, command, req, res) => event_manager_1.DASHBORD_EVENT_MANAGER.beforeSessionCommand(sessionId, command, req, res),
+    after: (sessionId, command, req, res, body) => event_manager_1.DASHBORD_EVENT_MANAGER.afterSessionCommand(sessionId, command, null, req, res, body),
+};
+/** A hub: sessions other servers run are forwarded to them. */
+function hubGatewayOptions(config) {
+    const basePath = (0, appiumBasePath_1.normalizeBasePath)(config.basePath);
+    const isLocalDevice = (device) => !device.cloud && (device.nodeId === config.nodeId() || config.isLocalHost(device.host));
+    const locator = new sessionLocator_1.SessionLocator(Object.assign(Object.assign({ getSession: (sessionId) => SessionManager_1.SESSION_MANAGER.getSession(sessionId) }, (0, sessionLocator_1.sessionRowsFrom)(prisma_1.prisma)), { isLocalDevice, webDriverUrlOf: (device) => (0, nodeWebDriverUrl_1.nodeWebDriverUrl)(device, basePath) }));
+    const tokens = () => typedi_1.Container.get(hubSessionToken_1.HubSessionTokenIssuer);
+    const routing = (0, sessionGateway_1.createHubRouting)({
+        basePath,
+        locate: (sessionId) => locator.locate(sessionId),
+        forget: (sessionId) => locator.forget(sessionId),
+        tokenFor: (sessionId) => tokens().tokenFor(sessionId),
+        forgetToken: (sessionId) => tokens().forget(sessionId),
+        deleteSession: (next, sessionId) => typedi_1.Container.get(SessionLifecycleService_1.SessionLifecycleService).deleteSession(next, sessionId),
+        touch: (sessionId) => (0, device_service_1.updateCmdExecutedTime)(sessionId),
+        commandName: (path, method) => (0, base_driver_1.routeToCommandName)(path, method, basePath),
+        get dashboard() {
+            return config.dashboard() ? dashboardHooks : undefined;
+        },
+        logger: logger_1.default.scope('SessionGateway'),
+    });
+    return { routing, latencyOf, create: createWith() };
+}
+/**
+ * A node: the hub's session token is accepted in place of the client's
+ * credentials, and its create token is a create's credential.
+ */
+function nodeGatewayOptions(hubUrl) {
+    const hub = new hubSessionToken_1.HubSessionTokenVerifier(hubUrl);
+    return { hubTokens: hub, latencyOf, create: createWith(hub) };
+}
+/** The gateway for this server: a node when it has a hub, a hub otherwise. */
+function gatewayOptionsFor(pluginArgs, cliArgs, nodeId) {
+    if (pluginArgs.hub !== undefined)
+        return nodeGatewayOptions(pluginArgs.hub);
+    const localHosts = (0, localDeviceHosts_1.localDeviceHosts)(pluginArgs, cliArgs.port);
+    return hubGatewayOptions({
+        basePath: cliArgs.basePath,
+        isLocalHost: (host) => (0, localDeviceHosts_1.isLocalDeviceHost)(localHosts, host),
+        nodeId,
+        dashboard: () => !!pluginArgs.enableDashboard,
+    });
+}

package/lib/src/gateway/forwardToNode.js

@@ -0,0 +1,147 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NODE_UNREACHABLE_BODY = exports.NODE_UNREACHABLE_STATUS = void 0;
+exports.forwardedRequestHeaders = forwardedRequestHeaders;
+exports.sendToNode = sendToNode;
+exports.relayAnswer = relayAnswer;
+exports.readAnswer = readAnswer;
+exports.sendAnswer = sendAnswer;
+const http_1 = __importDefault(require("http"));
+const https_1 = __importDefault(require("https"));
+const https_proxy_agent_1 = require("https-proxy-agent");
+const http_proxy_agent_1 = require("http-proxy-agent");
+const internalCall_1 = require("./internalCall");
+const hubSessionToken_1 = require("./hubSessionToken");
+/**
+ * Sending a session command on to the node that runs the session, and handing
+ * the node's answer back to the client unchanged.
+ */
+// Hop-by-hop headers describe one connection, not the message. `host` and
+// `content-length` are recomputed for the hop to the node.
+const HOP_BY_HOP = new Set([
+    'connection',
+    'keep-alive',
+    'proxy-authenticate',
+    'proxy-authorization',
+    'proxy-connection',
+    'te',
+    'trailer',
+    'transfer-encoding',
+    'upgrade',
+    'host',
+    'content-length',
+]);
+// The client's credentials were checked here and are not the node's business:
+// the node trusts the hub's session token instead. Xenon's own markers are
+// never taken from a client.
+const NEVER_FORWARDED = new Set([
+    'authorization',
+    'cookie',
+    'x-xenon-access-key',
+    'x-xenon-token',
+    internalCall_1.INTERNAL_CALL_HEADER,
+    hubSessionToken_1.HUB_TOKEN_HEADER,
+]);
+function forwardedRequestHeaders(incoming) {
+    const out = {};
+    for (const [name, value] of Object.entries(incoming)) {
+        const lower = name.toLowerCase();
+        if (value === undefined || HOP_BY_HOP.has(lower) || NEVER_FORWARDED.has(lower))
+            continue;
+        out[lower] = value;
+    }
+    // The answer is relayed byte for byte and read for the dashboard's command
+    // log, so ask for it uncompressed.
+    out['accept-encoding'] = 'identity';
+    return out;
+}
+/** HTTP(S)_PROXY from the environment, as the old command proxy honoured it. */
+function proxyAgentFor(url) {
+    const proxy = process.env.HTTP_PROXY || process.env.HTTPS_PROXY;
+    if (!proxy)
+        return undefined;
+    return url.protocol === 'https:' ? new https_proxy_agent_1.HttpsProxyAgent(proxy) : new http_proxy_agent_1.HttpProxyAgent(proxy);
+}
+/**
+ * Send one request to a node and resolve with its response stream. No retry:
+ * a WebDriver command is not safe to repeat. Credentials in the URL (a cloud
+ * provider's) become basic auth.
+ */
+function sendToNode(request) {
+    const url = new URL(request.url);
+    const lib = url.protocol === 'https:' ? https_1.default : http_1.default;
+    const headers = Object.assign({}, request.headers);
+    if (request.body)
+        headers['content-length'] = request.body.length;
+    return new Promise((resolve, reject) => {
+        const outgoing = lib.request(url, { method: request.method, headers, agent: proxyAgentFor(url), signal: request.signal }, resolve);
+        outgoing.on('error', reject);
+        outgoing.end(request.body);
+    });
+}
+function copyResponseHeaders(upstream, res) {
+    for (const [name, value] of Object.entries(upstream.headers)) {
+        if (value === undefined || HOP_BY_HOP.has(name.toLowerCase()))
+            continue;
+        res.setHeader(name, value);
+    }
+    if (upstream.headers['content-length'] !== undefined) {
+        res.setHeader('content-length', upstream.headers['content-length']);
+    }
+}
+/**
+ * Stream the node's answer to the client: its status, its headers (less the
+ * hop-by-hop ones) and its body, unchanged. With `capture`, also resolve with
+ * the body as text, for the dashboard's command log.
+ */
+function relayAnswer(upstream, res, capture) {
+    var _a;
+    res.status((_a = upstream.statusCode) !== null && _a !== void 0 ? _a : 502);
+    copyResponseHeaders(upstream, res);
+    const chunks = capture ? [] : undefined;
+    return new Promise((resolve, reject) => {
+        if (chunks)
+            upstream.on('data', (chunk) => chunks.push(chunk));
+        upstream.on('end', () => resolve(chunks ? Buffer.concat(chunks).toString('utf8') : undefined));
+        upstream.on('error', reject);
+        upstream.pipe(res);
+    });
+}
+/** Read a whole answer, for a caller that must act before replying (DELETE). */
+function readAnswer(upstream) {
+    return new Promise((resolve, reject) => {
+        const chunks = [];
+        upstream.on('data', (chunk) => chunks.push(chunk));
+        upstream.on('end', () => {
+            var _a;
+            return resolve({
+                status: (_a = upstream.statusCode) !== null && _a !== void 0 ? _a : 502,
+                headers: upstream.headers,
+                body: Buffer.concat(chunks),
+            });
+        });
+        upstream.on('error', reject);
+    });
+}
+function sendAnswer(res, answer) {
+    res.status(answer.status);
+    for (const [name, value] of Object.entries(answer.headers)) {
+        if (value === undefined || HOP_BY_HOP.has(name.toLowerCase()))
+            continue;
+        res.setHeader(name, value);
+    }
+    res.setHeader('content-length', answer.body.length);
+    res.end(answer.body);
+}
+/** WebDriver's `unknown error`, for a node that could not be reached. */
+exports.NODE_UNREACHABLE_STATUS = 500;
+exports.NODE_UNREACHABLE_BODY = {
+    value: {
+        error: 'unknown error',
+        message: 'Xenon could not reach the node running this session.',
+        stacktrace: '',
+    },
+};