@xenon-device-management/xenon 2.0.0 → 2.2.0

package/lib/src/gateway/nodeWebDriverUrl.js

@@ -0,0 +1,139 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NodeBasePathResolver = exports.LOOKUP_TIMEOUT_MS = exports.FALLBACK_TTL_MS = exports.BASE_PATH_TTL_MS = exports.WEBDRIVER_INFO_PATH = void 0;
+exports.webdriverInfo = webdriverInfo;
+exports.webdriverInfoHandler = webdriverInfoHandler;
+exports.originOf = originOf;
+exports.nodeWebDriverUrl = nodeWebDriverUrl;
+const https_1 = __importDefault(require("https"));
+const axios_1 = __importDefault(require("axios"));
+const typedi_1 = require("typedi");
+const logger_1 = __importDefault(require("../logger"));
+const helpers_1 = require("../helpers");
+const appiumBasePath_1 = require("../app/appiumBasePath");
+const PluginContext_1 = require("../PluginContext");
+/**
+ * Where a node's WebDriver API lives.
+ *
+ * A phone's `host` column is the node's origin (`http://<ip>:<port>`), never
+ * its Appium base path, and a hub and its nodes need not share one. So each
+ * Xenon server says what its base path is at `GET /xenon/api/webdriver`,
+ * which needs no login (the path is part of every client's URL anyway), and
+ * the hub asks a node before it sends that node a session or a command.
+ *
+ * The answer is kept for a minute. A node that does not answer it (an older
+ * Xenon, or one that is down) is taken to share the hub's own base path, the
+ * one rule that held before, and asked again after a few seconds.
+ */
+exports.WEBDRIVER_INFO_PATH = '/xenon/api/webdriver';
+exports.BASE_PATH_TTL_MS = 60000;
+exports.FALLBACK_TTL_MS = 10000;
+exports.LOOKUP_TIMEOUT_MS = 3000;
+/** What a server answers at WEBDRIVER_INFO_PATH. */
+function webdriverInfo(basePath) {
+    return { basePath: (0, appiumBasePath_1.normalizeBasePath)(basePath) };
+}
+function webdriverInfoHandler(basePath) {
+    return (_req, res) => {
+        res.json(webdriverInfo(basePath()));
+    };
+}
+/** A phone host's origin: scheme, host and port, without a path or trailing slash. */
+function originOf(host) {
+    try {
+        return new URL(host).origin;
+    }
+    catch (_a) {
+        return host.replace(/\/+$/, '');
+    }
+}
+let NodeBasePathResolver = class NodeBasePathResolver {
+    constructor() {
+        this.logger = logger_1.default.scope('NodeBasePath');
+        this.cache = new Map();
+        this.pending = new Map();
+        this.now = () => Date.now();
+    }
+    /** The node's base path, or `fallback` when the node does not say. */
+    resolve(origin, fallback) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const hit = this.cache.get(origin);
+            if (hit && hit.expiresAt > this.now())
+                return hit.basePath;
+            const inFlight = this.pending.get(origin);
+            if (inFlight)
+                return inFlight;
+            const lookup = this.lookUp(origin, (0, appiumBasePath_1.normalizeBasePath)(fallback)).finally(() => this.pending.delete(origin));
+            this.pending.set(origin, lookup);
+            return lookup;
+        });
+    }
+    forget(origin) {
+        this.cache.delete(origin);
+    }
+    lookUp(origin, fallback) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c;
+            let advertised;
+            try {
+                const rejectUnauthorized = (_a = typedi_1.Container.get(PluginContext_1.PluginContext).pluginArgs) === null || _a === void 0 ? void 0 : _a.tlsRejectUnauthorized;
+                const response = yield axios_1.default.get(`${origin}${exports.WEBDRIVER_INFO_PATH}`, {
+                    timeout: exports.LOOKUP_TIMEOUT_MS,
+                    validateStatus: (status) => status === 200,
+                    httpsAgent: new https_1.default.Agent({ rejectUnauthorized: rejectUnauthorized !== false }),
+                });
+                const basePath = (_b = response.data) === null || _b === void 0 ? void 0 : _b.basePath;
+                if (typeof basePath === 'string')
+                    advertised = (0, appiumBasePath_1.normalizeBasePath)(basePath);
+            }
+            catch (err) {
+                this.logger.debug(`${origin} did not say its base path (${(_c = err === null || err === void 0 ? void 0 : err.message) !== null && _c !== void 0 ? _c : err})`);
+            }
+            if (advertised === undefined) {
+                this.logger.info(`Node ${origin} did not report its WebDriver base path; using this hub's ('${fallback}').`);
+            }
+            const basePath = advertised !== null && advertised !== void 0 ? advertised : fallback;
+            this.cache.set(origin, {
+                basePath,
+                expiresAt: this.now() + (advertised === undefined ? exports.FALLBACK_TTL_MS : exports.BASE_PATH_TTL_MS),
+            });
+            return basePath;
+        });
+    }
+};
+exports.NodeBasePathResolver = NodeBasePathResolver;
+exports.NodeBasePathResolver = NodeBasePathResolver = __decorate([
+    (0, typedi_1.Service)()
+], NodeBasePathResolver);
+/**
+ * The WebDriver base URL of the server that drives a phone: a cloud
+ * provider's own URL, or a node's origin plus its own base path.
+ * `fallbackBasePath` is this hub's, for a node that does not say.
+ */
+function nodeWebDriverUrl(device, fallbackBasePath) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (device.cloud)
+            return (0, helpers_1.nodeUrl)(device, fallbackBasePath);
+        const origin = originOf(device.host);
+        const basePath = yield typedi_1.Container.get(NodeBasePathResolver).resolve(origin, fallbackBasePath);
+        return `${origin}${basePath}`;
+    });
+}

package/lib/src/gateway/sessionCreate.js

@@ -0,0 +1,136 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSessionCreateLayer = createSessionCreateLayer;
+const base_driver_1 = require("@appium/base-driver");
+const commandAuth_1 = require("../middleware/commandAuth");
+const createHandoff_1 = require("./createHandoff");
+const hubSessionToken_1 = require("./hubSessionToken");
+function isPlainObject(value) {
+    return !!value && typeof value === 'object' && !Array.isArray(value);
+}
+/** The path under the layer's mount point is the create path itself. */
+function isCreatePath(url) {
+    const path = (url || '/').split('?')[0];
+    return path === '/' || path === '';
+}
+/** Answer an error as Appium's route answers it. */
+function sendError(res, error) {
+    if (res.headersSent)
+        return;
+    const err = error instanceof Error ? error : new Error(String(error));
+    const [status, body] = (0, base_driver_1.getResponseForW3CError)(err);
+    res.status(status).json(body);
+}
+/** Appium's answer to a new session: `{ value: { capabilities, sessionId } }`. */
+function newSessionBody(created) {
+    var _a;
+    const value = created === null || created === void 0 ? void 0 : created.value;
+    if (!Array.isArray(value) || typeof value[0] !== 'string') {
+        throw new base_driver_1.errors.SessionNotCreatedError('The node answered the create without a session id.');
+    }
+    return { value: { capabilities: (_a = value[1]) !== null && _a !== void 0 ? _a : null, sessionId: value[0] } };
+}
+function createSessionCreateLayer(deps) {
+    const { logger } = deps;
+    /** The grant a node creates by, or false when the request has been answered. */
+    function hubGrantOf(token, res) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (token === undefined || !deps.hubGrants || deps.authDisabled())
+                return undefined;
+            let grant;
+            try {
+                grant = yield deps.hubGrants.verifyCreate(token);
+            }
+            catch (error) {
+                logger.error(`New session refused: the hub's token could not be checked: ${(0, commandAuth_1.summarize)(error)}`);
+                res.status(commandAuth_1.COMMAND_AUTH_UNAVAILABLE_STATUS).json(commandAuth_1.COMMAND_AUTH_UNAVAILABLE_BODY);
+                return false;
+            }
+            if (grant)
+                return grant;
+            logger.warn("New session refused: the hub's token on it is not valid");
+            sendError(res, new base_driver_1.errors.InvalidArgumentError("session rejected: the hub's token for this session is not valid " +
+                '(forged, expired, already used, or not a create token)'));
+            return false;
+        });
+    }
+    function create(res, next, caps, token) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Registered before anything waits, so a client that leaves while its
+            // phone is being found is seen.
+            const request = {
+                closed: false,
+            };
+            res.on('close', () => {
+                var _a;
+                request.closed = true;
+                (_a = request.handoff) === null || _a === void 0 ? void 0 : _a.abandon();
+            });
+            const hubGrant = yield hubGrantOf(token, res);
+            if (hubGrant === false)
+                return;
+            const lifecycle = deps.lifecycle();
+            let allocation;
+            try {
+                allocation = yield lifecycle.prepareSession(caps, hubGrant ? { hubGrant } : {});
+            }
+            catch (error) {
+                logger.warn(`New session refused: ${(0, commandAuth_1.summarize)(error)}`);
+                sendError(res, error);
+                return;
+            }
+            if (request.closed) {
+                logger.warn('The client left before its session was created; its device was released.');
+                yield lifecycle.releaseAllocation(allocation);
+                return;
+            }
+            if (allocation.remote) {
+                try {
+                    res.status(200).json(newSessionBody(yield lifecycle.completeRemoteSession(allocation)));
+                }
+                catch (error) {
+                    sendError(res, error);
+                }
+                return;
+            }
+            const local = new createHandoff_1.CreateHandoff(allocation, (unused) => {
+                logger.warn("A new session's device was allocated, but the request ended without Xenon's " +
+                    'createSession taking it; the device was released.');
+                lifecycle
+                    .releaseAllocation(unused)
+                    .catch((error) => logger.error(`Could not release a device: ${(0, commandAuth_1.summarize)(error)}`));
+            });
+            request.handoff = local;
+            (0, createHandoff_1.runWithCreateHandoff)(local, () => next());
+        });
+    }
+    return function xenonSessionCreate(req, res, next) {
+        if (req.method !== 'POST' || !isCreatePath(req.url))
+            return next();
+        // The hub's token is for this layer alone: nothing after it sees it.
+        const presented = req.headers[hubSessionToken_1.HUB_TOKEN_HEADER];
+        const token = typeof presented === 'string' ? presented : undefined;
+        delete req.headers[hubSessionToken_1.HUB_TOKEN_HEADER];
+        // Anything but a capabilities object is Appium's to answer, as before.
+        const caps = isPlainObject(req.body) ? req.body.capabilities : undefined;
+        if (!isPlainObject(caps))
+            return next();
+        // W3C lets clients omit `firstMatch` (it defaults to [{}]); what reads the
+        // caps from here on relies on `firstMatch[0]`, as the plugin did.
+        if (!Array.isArray(caps.firstMatch) || caps.firstMatch.length === 0)
+            caps.firstMatch = [{}];
+        create(res, next, caps, token).catch((error) => {
+            logger.error(`Session gateway: a create failed: ${(0, commandAuth_1.summarize)(error)}`);
+            sendError(res, error);
+        });
+    };
+}

package/lib/src/gateway/sessionGateway.js

@@ -0,0 +1,201 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ROUTING_UNAVAILABLE_BODY = exports.ROUTING_UNAVAILABLE_STATUS = void 0;
+exports.createSessionGatewayLayer = createSessionGatewayLayer;
+exports.createHubRouting = createHubRouting;
+const commandAuth_1 = require("../middleware/commandAuth");
+const internalCall_1 = require("./internalCall");
+const hubSessionToken_1 = require("./hubSessionToken");
+const forwardToNode_1 = require("./forwardToNode");
+/** Where a session runs could not be determined (a database error). */
+exports.ROUTING_UNAVAILABLE_STATUS = 503;
+exports.ROUTING_UNAVAILABLE_BODY = {
+    value: {
+        error: 'unknown error',
+        message: 'Xenon could not find where this session runs. Try again.',
+        stacktrace: '',
+    },
+};
+function headerValue(req, name) {
+    const value = req.headers[name];
+    return typeof value === 'string' ? value : undefined;
+}
+function where(req) {
+    var _a;
+    return `${req.method} ${String((_a = req.originalUrl) !== null && _a !== void 0 ? _a : req.url).split('?')[0]}`;
+}
+function createSessionGatewayLayer(deps) {
+    const authorize = (0, commandAuth_1.createCommandAuthMiddleware)(deps.auth);
+    const logger = deps.auth.logger;
+    const authActive = () => deps.auth.enabled() && !deps.auth.authDisabled();
+    function route(req, res, next, sessionId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            // A request that came from a hub is never forwarded again: a hub that
+            // routed a session to itself would otherwise loop.
+            const fromHub = headerValue(req, hubSessionToken_1.HUB_TOKEN_HEADER) !== undefined;
+            delete req.headers[hubSessionToken_1.HUB_TOKEN_HEADER];
+            if (deps.routing && !fromHub) {
+                let location;
+                try {
+                    location = yield deps.routing.locate(sessionId);
+                }
+                catch (error) {
+                    logger.error(`Could not find where session ${sessionId} runs for ${where(req)}: ${(0, commandAuth_1.summarize)(error)}`);
+                    res.status(exports.ROUTING_UNAVAILABLE_STATUS).json(exports.ROUTING_UNAVAILABLE_BODY);
+                    return;
+                }
+                if (location.kind === 'remote') {
+                    yield deps.routing.forward(req, res, sessionId, location);
+                    return;
+                }
+            }
+            const latency = (_b = (_a = deps.latencyOf) === null || _a === void 0 ? void 0 : _a.call(deps, sessionId)) !== null && _b !== void 0 ? _b : 0;
+            if (latency > 0)
+                yield new Promise((resolve) => setTimeout(resolve, latency));
+            next();
+        });
+    }
+    return function xenonSessionGateway(req, res, next) {
+        var _a, _b;
+        const sessionId = String((_b = (_a = req.params) === null || _a === void 0 ? void 0 : _a.sessionId) !== null && _b !== void 0 ? _b : '');
+        const proceed = () => {
+            route(req, res, next, sessionId).catch((error) => {
+                logger.error(`Session gateway failed for ${where(req)}: ${(0, commandAuth_1.summarize)(error)}`);
+                if (!res.headersSent)
+                    res.status(forwardToNode_1.NODE_UNREACHABLE_STATUS).json(forwardToNode_1.NODE_UNREACHABLE_BODY);
+            });
+        };
+        if ((0, internalCall_1.isInternalCall)(req))
+            return proceed();
+        const hubToken = headerValue(req, hubSessionToken_1.HUB_TOKEN_HEADER);
+        if (hubToken !== undefined && deps.hubTokens && authActive()) {
+            deps.hubTokens
+                .verify(hubToken, sessionId)
+                .then((valid) => {
+                if (valid)
+                    return proceed();
+                logger.warn(`Command refused: ${where(req)} (session ${sessionId}): hub token not valid for this session`);
+                res.status(commandAuth_1.UNKNOWN_SESSION_STATUS).json(commandAuth_1.UNKNOWN_SESSION_BODY);
+            })
+                .catch((error) => {
+                logger.error(`Command auth unavailable for ${where(req)} (session ${sessionId}): ` +
+                    `hub token check failed: ${(0, commandAuth_1.summarize)(error)}`);
+                if (!res.headersSent) {
+                    res.status(commandAuth_1.COMMAND_AUTH_UNAVAILABLE_STATUS).json(commandAuth_1.COMMAND_AUTH_UNAVAILABLE_BODY);
+                }
+            });
+            return;
+        }
+        authorize(req, res, proceed);
+    };
+}
+const BODYLESS = new Set(['GET', 'HEAD', 'DELETE', 'OPTIONS']);
+/** The part of the path after `/session/<id>`, with its query string, from the mounted layer. */
+function restOf(req) {
+    const url = req.url || '/';
+    const q = url.indexOf('?');
+    const pathname = q === -1 ? url : url.slice(0, q);
+    const query = q === -1 ? '' : url.slice(q);
+    return `${pathname === '/' ? '' : pathname}${query}`;
+}
+function createHubRouting(deps) {
+    const { logger } = deps;
+    function nodeRequest(req, sessionId, location, signal) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const headers = (0, forwardToNode_1.forwardedRequestHeaders)(req.headers);
+            if (!location.cloud) {
+                const token = yield deps.tokenFor(sessionId);
+                if (token)
+                    headers[hubSessionToken_1.HUB_TOKEN_HEADER] = token;
+            }
+            let body;
+            if (!BODYLESS.has(req.method.toUpperCase())) {
+                body = Buffer.from(JSON.stringify((_a = req.body) !== null && _a !== void 0 ? _a : {}));
+                headers['content-type'] = 'application/json; charset=utf-8';
+            }
+            return {
+                url: `${location.url}/session/${encodeURIComponent(sessionId)}${restOf(req)}`,
+                method: req.method,
+                headers,
+                body,
+                signal,
+            };
+        });
+    }
+    function deleteRemote(req, res, sessionId, location) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let answer;
+            yield deps.deleteSession(() => __awaiter(this, void 0, void 0, function* () {
+                answer = yield (0, forwardToNode_1.readAnswer)(yield (0, forwardToNode_1.sendToNode)(yield nodeRequest(req, sessionId, location)));
+                return answer;
+            }), sessionId);
+            deps.forget(sessionId);
+            deps.forgetToken(sessionId);
+            if (answer) {
+                (0, forwardToNode_1.sendAnswer)(res, answer);
+            }
+            else {
+                logger.warn(`Session ${sessionId}: the node did not answer its DELETE; ended here anyway.`);
+                res.status(forwardToNode_1.NODE_UNREACHABLE_STATUS).json(forwardToNode_1.NODE_UNREACHABLE_BODY);
+            }
+        });
+    }
+    return {
+        locate: (sessionId) => deps.locate(sessionId),
+        forward(req, res, sessionId, location) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const rest = restOf(req);
+                if (req.method.toUpperCase() === 'DELETE' && (rest === '' || rest.startsWith('?'))) {
+                    yield deleteRemote(req, res, sessionId, location);
+                    return;
+                }
+                yield deps
+                    .touch(sessionId)
+                    .catch((error) => logger.warn(`Could not record activity for session ${sessionId}: ${(0, commandAuth_1.summarize)(error)}`));
+                const hooks = location.session && !location.cloud ? deps.dashboard : undefined;
+                const command = hooks
+                    ? deps.commandName(`${deps.basePath}/session/${sessionId}${rest.split('?')[0]}`, req.method)
+                    : undefined;
+                if (hooks && !(yield hooks.before(sessionId, command, req, res)))
+                    return;
+                // A client that goes away takes its forwarded command with it.
+                const abort = new AbortController();
+                res.on('close', () => {
+                    if (!res.writableFinished)
+                        abort.abort();
+                });
+                let captured;
+                try {
+                    const upstream = yield (0, forwardToNode_1.sendToNode)(yield nodeRequest(req, sessionId, location, abort.signal));
+                    captured = yield (0, forwardToNode_1.relayAnswer)(upstream, res, !!hooks);
+                }
+                catch (error) {
+                    if (abort.signal.aborted)
+                        return;
+                    logger.error(`Could not forward ${req.method} for session ${sessionId} to ${location.url}: ${(0, commandAuth_1.summarize)(error)}`);
+                    if (!res.headersSent)
+                        res.status(forwardToNode_1.NODE_UNREACHABLE_STATUS).json(forwardToNode_1.NODE_UNREACHABLE_BODY);
+                    else
+                        res.destroy();
+                    return;
+                }
+                if (hooks && captured !== undefined) {
+                    yield hooks
+                        .after(sessionId, command, req, res, captured)
+                        .catch((error) => logger.warn(`Dashboard log failed for session ${sessionId}: ${(0, commandAuth_1.summarize)(error)}`));
+                }
+            });
+        },
+    };
+}

package/lib/src/gateway/sessionLocator.js

@@ -0,0 +1,100 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SessionLocator = exports.LOCAL = void 0;
+exports.sessionRowsFrom = sessionRowsFrom;
+const SessionType_1 = __importDefault(require("../enums/SessionType"));
+exports.LOCAL = { kind: 'local' };
+class SessionLocator {
+    constructor(deps) {
+        var _a;
+        this.deps = deps;
+        this.remembered = new Map();
+        this.maxRemembered = (_a = deps.maxRemembered) !== null && _a !== void 0 ? _a : 1000;
+    }
+    locate(sessionId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const live = this.deps.getSession(sessionId);
+            if (live)
+                return this.locationOf(live);
+            const known = this.remembered.get(sessionId);
+            if (known)
+                return known;
+            let location = exports.LOCAL;
+            const row = yield this.deps.findOpenSession(sessionId);
+            if (row) {
+                const device = yield this.deps.findDevice(row.device_udid, row.node_id);
+                if (device && !this.deps.isLocalDevice(device)) {
+                    location = {
+                        kind: 'remote',
+                        url: yield this.deps.webDriverUrlOf(device),
+                        cloud: !!device.cloud,
+                    };
+                }
+            }
+            this.remember(sessionId, location);
+            return location;
+        });
+    }
+    forget(sessionId) {
+        this.remembered.delete(sessionId);
+    }
+    locationOf(session) {
+        const type = session.getType();
+        const getUrl = session.getWebDriverUrl;
+        if (type === SessionType_1.default.LOCAL || typeof getUrl !== 'function')
+            return exports.LOCAL;
+        // A session recovered as remote whose phone is this server's own (a local
+        // session from before a restart) must not be sent back to this server.
+        if (this.deps.isLocalDevice(session.getDevice()))
+            return exports.LOCAL;
+        return {
+            kind: 'remote',
+            url: getUrl.call(session),
+            cloud: type === SessionType_1.default.CLOUD,
+            session,
+        };
+    }
+    remember(sessionId, location) {
+        if (this.remembered.size >= this.maxRemembered) {
+            const oldest = this.remembered.keys().next().value;
+            this.remembered.delete(oldest);
+        }
+        this.remembered.set(sessionId, location);
+    }
+}
+exports.SessionLocator = SessionLocator;
+/** The database side of SessionLocatorDeps, on a Prisma client. */
+function sessionRowsFrom(db) {
+    return {
+        findOpenSession: (sessionId) => __awaiter(this, void 0, void 0, function* () {
+            if (!sessionId)
+                return null;
+            const row = yield db.session.findFirst({
+                where: { id: sessionId, endTime: null },
+                select: { device_udid: true, node_id: true },
+            });
+            return row !== null && row !== void 0 ? row : null;
+        }),
+        findDevice: (udid, nodeId) => __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            if (nodeId) {
+                const onNode = yield db.device.findFirst({ where: { udid, nodeId } });
+                if (onNode)
+                    return onNode;
+            }
+            return (_a = (yield db.device.findFirst({ where: { udid } }))) !== null && _a !== void 0 ? _a : null;
+        }),
+    };
+}