@xenon-device-management/xenon 2.0.0 → 2.2.0

package/lib/test/unit/node-phone-control.spec.js

@@ -0,0 +1,131 @@
+"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 });
+require("reflect-metadata");
+const chai_1 = require("chai");
+const express_1 = __importDefault(require("express"));
+const typedi_1 = require("typedi");
+const loopbackRequest_1 = __importDefault(require("../helpers/loopbackRequest"));
+const loopbackServer_1 = require("../helpers/loopbackServer");
+const PluginContext_1 = require("../../src/PluginContext");
+const IPluginArgs_1 = require("../../src/interfaces/IPluginArgs");
+const nodePhoneControl_1 = require("../../src/app/routers/nodePhoneControl");
+/**
+ * The gate in front of /control's handlers, on its own: what it does when the
+ * phone's node is slow or its row can't be read. The actions themselves are
+ * in hub-node-control-forward.spec.ts.
+ */
+describe('nodePhoneControl', () => {
+    const loopback = (0, loopbackServer_1.loopbackServers)();
+    let context;
+    let saved;
+    let findDevice;
+    let held;
+    beforeEach(() => {
+        context = typedi_1.Container.get(PluginContext_1.PluginContext);
+        saved = Object.assign({}, context);
+        context.setContext(Object.assign(Object.assign({}, IPluginArgs_1.DefaultPluginArgs), { bindHostOrIp: '127.0.0.1' }), 1, 'hub-1', '');
+        held = [];
+    });
+    afterEach(() => __awaiter(void 0, void 0, void 0, function* () {
+        Object.assign(context, saved);
+        yield loopback.closeAll();
+    }));
+    const app = (timeoutMs = 60000) => {
+        const a = (0, express_1.default)();
+        a.use(express_1.default.json());
+        a.use('/xenon/api/control', (0, nodePhoneControl_1.nodePhoneControl)({ findDevice: (udid) => findDevice(udid), timeoutMs }), (_req, res) => res.status(299).json({ handledHere: true }));
+        return a;
+    };
+    it('a node that doesn’t answer in time: 504, naming it', () => __awaiter(void 0, void 0, void 0, function* () {
+        const node = (0, express_1.default)();
+        node.use((req) => held.push(req)); // never answers
+        const origin = `http://127.0.0.1:${(yield loopback.serve(node)).address().port}`;
+        findDevice = () => __awaiter(void 0, void 0, void 0, function* () { return ({ udid: 'p', host: origin, nodeId: 'node-1' }); });
+        const res = yield (0, loopbackRequest_1.default)(app(150)).get('/xenon/api/control/p/screenshot');
+        (0, chai_1.expect)(res.status).to.equal(504);
+        (0, chai_1.expect)(res.body.error).to.equal('node_timeout');
+        (0, chai_1.expect)(res.body.message).to.include(origin);
+        (0, chai_1.expect)(held).to.have.length(1);
+    }));
+    it('a device row that can’t be read: 503, and no handler runs it here', () => __awaiter(void 0, void 0, void 0, function* () {
+        findDevice = () => __awaiter(void 0, void 0, void 0, function* () {
+            throw new Error('database is locked');
+        });
+        const res = yield (0, loopbackRequest_1.default)(app()).post('/xenon/api/control/p/tap').send({ x: 1, y: 2 });
+        (0, chai_1.expect)(res.status).to.equal(503);
+        (0, chai_1.expect)(res.body.error).to.equal('device_ownership_unavailable');
+    }));
+    it('this server’s own phone, and an unknown one, go to the handlers', () => __awaiter(void 0, void 0, void 0, function* () {
+        findDevice = () => __awaiter(void 0, void 0, void 0, function* () { return ({ udid: 'p', host: 'http://10.0.0.9:4725', nodeId: 'hub-1' }); });
+        yield (0, loopbackRequest_1.default)(app()).post('/xenon/api/control/p/tap').send({}).expect(299);
+        findDevice = () => __awaiter(void 0, void 0, void 0, function* () { return null; });
+        yield (0, loopbackRequest_1.default)(app()).post('/xenon/api/control/p/tap').send({}).expect(299);
+    }));
+    it('a stream outlives the timeout once the node has answered', () => __awaiter(void 0, void 0, void 0, function* () {
+        const node = (0, express_1.default)();
+        node.get('/xenon/api/control/p/stream', (_req, res) => {
+            // Text, so the test's client doesn't try to parse it; an MJPEG
+            // answer is relayed the same way.
+            res.writeHead(200, { 'content-type': 'text/plain' });
+            res.write('frame one;');
+            setTimeout(() => res.end('frame two;'), 400);
+        });
+        const origin = `http://127.0.0.1:${(yield loopback.serve(node)).address().port}`;
+        findDevice = () => __awaiter(void 0, void 0, void 0, function* () { return ({ udid: 'p', host: origin, nodeId: 'node-1' }); });
+        const res = yield (0, loopbackRequest_1.default)(app(150)).get('/xenon/api/control/p/stream');
+        (0, chai_1.expect)(res.status).to.equal(200);
+        (0, chai_1.expect)(res.text).to.equal('frame one;frame two;');
+    }));
+    it('sends the node none of the caller’s ticket, and the rest of the query', () => __awaiter(void 0, void 0, void 0, function* () {
+        const node = (0, express_1.default)();
+        const seen = [];
+        node.use((req, res) => {
+            seen.push(req.originalUrl);
+            res.json({ status: 'stopped' });
+        });
+        const origin = `http://127.0.0.1:${(yield loopback.serve(node)).address().port}`;
+        findDevice = () => __awaiter(void 0, void 0, void 0, function* () { return ({ udid: 'p', host: origin, nodeId: 'node-1' }); });
+        yield (0, loopbackRequest_1.default)(app()).get('/xenon/api/control/p/stream/status?ticket=spent&t=1&r=2').expect(200);
+        (0, chai_1.expect)(seen).to.deep.equal(['/xenon/api/control/p/stream/status?t=1&r=2']);
+    }));
+    it('marks the phone busy for its node once the node has started a preview, and only then', () => __awaiter(void 0, void 0, void 0, function* () {
+        let answer = 200;
+        const node = (0, express_1.default)();
+        node.use((_req, res) => res.status(answer).json({}));
+        const origin = `http://127.0.0.1:${(yield loopback.serve(node)).address().port}`;
+        findDevice = () => __awaiter(void 0, void 0, void 0, function* () { return ({ udid: 'p', host: origin, nodeId: 'node-1' }); });
+        const marked = [];
+        const a = (0, express_1.default)();
+        a.use(express_1.default.json());
+        a.use('/xenon/api/control', (0, nodePhoneControl_1.nodePhoneControl)({
+            findDevice: (udid) => findDevice(udid),
+            markNodeBusy: (udid, host) => __awaiter(void 0, void 0, void 0, function* () {
+                marked.push(`${udid}@${host}`);
+            }),
+        }));
+        yield (0, loopbackRequest_1.default)(a).post('/xenon/api/control/p/stream/start').send({}).expect(200);
+        answer = 409;
+        yield (0, loopbackRequest_1.default)(a).post('/xenon/api/control/p/stream/start').send({}).expect(409);
+        answer = 200;
+        yield (0, loopbackRequest_1.default)(a).get('/xenon/api/control/p/stream/status').expect(200);
+        (0, chai_1.expect)(marked).to.deep.equal([`p@${origin}`]);
+    }));
+    it('refuses a host it must never call', () => __awaiter(void 0, void 0, void 0, function* () {
+        findDevice = () => __awaiter(void 0, void 0, void 0, function* () { return ({ udid: 'p', host: 'http://169.254.169.254', nodeId: 'node-1' }); });
+        const res = yield (0, loopbackRequest_1.default)(app()).get('/xenon/api/control/p/screenshot');
+        (0, chai_1.expect)(res.status).to.equal(400);
+        (0, chai_1.expect)(res.body).to.deep.equal({ error: 'Unsafe device host' });
+    }));
+});

package/lib/test/unit/node-socket-relay.spec.js

@@ -0,0 +1,357 @@
+"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 });
+require("reflect-metadata");
+const chai_1 = require("chai");
+const http_1 = __importDefault(require("http"));
+const events_1 = require("events");
+const express_1 = __importDefault(require("express"));
+const typedi_1 = require("typedi");
+const ws_1 = require("ws");
+const loopbackServer_1 = require("../helpers/loopbackServer");
+const PluginContext_1 = require("../../src/PluginContext");
+const IPluginArgs_1 = require("../../src/interfaces/IPluginArgs");
+const nodeSocketRelay_1 = require("../../src/app/ws/nodeSocketRelay");
+const h264StreamWs_1 = require("../../src/app/ws/h264StreamWs");
+const logcatWs_1 = require("../../src/app/ws/logcatWs");
+/**
+ * The H.264 and logcat sockets for a node's phone, on a hub: the hub checks
+ * its own ticket, opens the same socket on the node with a ticket of the
+ * node's own, and relays it. Frames and close codes pass unchanged, and a
+ * viewer that falls behind holds the node back rather than growing the
+ * hub's memory, so the node's own slow-viewer rule applies (dropped H.264
+ * frames, a visible "lines dropped" record in logcat).
+ */
+const opened = (ws) => new Promise((resolve, reject) => {
+    ws.once('open', () => resolve());
+    ws.once('error', reject);
+});
+const closed = (ws) => new Promise((resolve) => ws.once('close', (code, reason) => resolve({ code, reason: reason.toString() })));
+const nextMessage = (ws) => new Promise((resolve) => ws.once('message', (data, isBinary) => resolve({ data: data, isBinary })));
+/** An upstream socket as openNodeSocket hands one over: open and paused. */
+const nodeSocketAt = (url) => __awaiter(void 0, void 0, void 0, function* () {
+    const up = new ws_1.WebSocket(url);
+    yield new Promise((resolve, reject) => {
+        up.once('open', () => {
+            up.pause();
+            resolve();
+        });
+        up.once('error', reject);
+    });
+    return up;
+});
+describe('nodeSocketRelay', () => {
+    const loopback = (0, loopbackServer_1.loopbackServers)();
+    const sockets = [];
+    let context;
+    let saved;
+    beforeEach(() => {
+        context = typedi_1.Container.get(PluginContext_1.PluginContext);
+        saved = Object.assign({}, context);
+        context.setContext(Object.assign(Object.assign({}, IPluginArgs_1.DefaultPluginArgs), { bindHostOrIp: '127.0.0.1' }), 1, 'hub-1', '');
+    });
+    afterEach(() => __awaiter(void 0, void 0, void 0, function* () {
+        Object.assign(context, saved);
+        for (const wss of sockets.splice(0)) {
+            for (const client of wss.clients)
+                client.terminate();
+            wss.close();
+        }
+        yield loopback.closeAll();
+    }));
+    /** A node: a ticket route and a socket on the same server. */
+    function fakeNode() {
+        return __awaiter(this, arguments, void 0, function* (opts = {}) {
+            const seen = [];
+            const app = (0, express_1.default)();
+            app.post('/xenon/api/control/:udid/stream/ticket', (req, res) => {
+                var _a;
+                seen.push({ url: req.originalUrl, hubToken: req.header('x-xenon-hub-token') });
+                res.status((_a = opts.ticketStatus) !== null && _a !== void 0 ? _a : 200).json({ ticket: 'node-ticket', expiresIn: 60 });
+            });
+            const server = yield loopback.serve(app);
+            const wss = new ws_1.WebSocketServer({ server });
+            sockets.push(wss);
+            wss.on('connection', (ws, req) => {
+                var _a;
+                seen.push({ url: req.url });
+                (_a = opts.onSocket) === null || _a === void 0 ? void 0 : _a.call(opts, ws, req.url);
+            });
+            const origin = `http://127.0.0.1:${server.address().port}`;
+            return { origin, seen, wss };
+        });
+    }
+    /** A hub socket whose connections are relayed to `upstream()`. */
+    function relayingHub(upstream, highWaterBytes) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const server = yield loopback.serve((0, express_1.default)());
+            const wss = new ws_1.WebSocketServer({ server });
+            sockets.push(wss);
+            wss.on('connection', (client) => __awaiter(this, void 0, void 0, function* () {
+                (0, nodeSocketRelay_1.relaySocket)(client, yield upstream(), highWaterBytes);
+            }));
+            return `ws://127.0.0.1:${server.address().port}`;
+        });
+    }
+    describe('relaySocket', () => {
+        it('passes messages both ways, binary and text as they were', () => __awaiter(void 0, void 0, void 0, function* () {
+            let atNode;
+            const node = yield fakeNode({ onSocket: (ws) => (atNode = ws) });
+            const hub = yield relayingHub(() => nodeSocketAt(`${node.origin.replace('http', 'ws')}/x`));
+            const viewer = new ws_1.WebSocket(hub);
+            yield opened(viewer);
+            yield new Promise((r) => setTimeout(r, 50));
+            const binary = nextMessage(viewer);
+            atNode.send(Buffer.from([1, 2, 3]));
+            (0, chai_1.expect)(yield binary).to.deep.equal({ data: Buffer.from([1, 2, 3]), isBinary: true });
+            const text = nextMessage(viewer);
+            atNode.send('{"message":"a line"}');
+            const got = yield text;
+            (0, chai_1.expect)(got.isBinary).to.equal(false);
+            (0, chai_1.expect)(got.data.toString()).to.equal('{"message":"a line"}');
+            const fromViewer = nextMessage(atNode);
+            viewer.send('hello');
+            (0, chai_1.expect)((yield fromViewer).data.toString()).to.equal('hello');
+            viewer.close();
+        }));
+        it('closes the viewer with the node’s own code and reason', () => __awaiter(void 0, void 0, void 0, function* () {
+            for (const [code, reason] of [
+                [1012, 'stream ended'],
+                [1008, 'device held by another user'],
+                [1011, 'stream failed'],
+            ]) {
+                const node = yield fakeNode({
+                    onSocket: (ws) => setTimeout(() => ws.close(code, reason), 30),
+                });
+                const hub = yield relayingHub(() => nodeSocketAt(`${node.origin.replace('http', 'ws')}/x`));
+                const viewer = new ws_1.WebSocket(hub);
+                (0, chai_1.expect)(yield closed(viewer)).to.deep.equal({ code, reason });
+            }
+        }));
+        it('a node connection that drops is 1011 to the viewer, who retries', () => __awaiter(void 0, void 0, void 0, function* () {
+            const node = yield fakeNode({ onSocket: (ws) => setTimeout(() => ws.terminate(), 30) });
+            const hub = yield relayingHub(() => nodeSocketAt(`${node.origin.replace('http', 'ws')}/x`));
+            const viewer = new ws_1.WebSocket(hub);
+            (0, chai_1.expect)((yield closed(viewer)).code).to.equal(1011);
+        }));
+        it('the viewer leaving closes the node’s socket', () => __awaiter(void 0, void 0, void 0, function* () {
+            let atNode;
+            const node = yield fakeNode({ onSocket: (ws) => (atNode = ws) });
+            const hub = yield relayingHub(() => nodeSocketAt(`${node.origin.replace('http', 'ws')}/x`));
+            const viewer = new ws_1.WebSocket(hub);
+            yield opened(viewer);
+            yield new Promise((r) => setTimeout(r, 50));
+            const nodeClosed = closed(atNode);
+            viewer.close();
+            yield nodeClosed;
+        }));
+        it('stops reading from the node while the viewer is behind, and resumes once it catches up', () => {
+            class FakeSocket extends events_1.EventEmitter {
+                constructor() {
+                    super(...arguments);
+                    this.readyState = ws_1.WebSocket.OPEN;
+                    this.paused = false;
+                    this.pending = [];
+                }
+                send(_data, _opts, cb) {
+                    this.pending.push(cb);
+                }
+                pause() {
+                    this.paused = true;
+                }
+                resume() {
+                    this.paused = false;
+                }
+                close() { }
+                terminate() { }
+            }
+            const viewer = new FakeSocket();
+            const node = new FakeSocket();
+            (0, nodeSocketRelay_1.relaySocket)(viewer, node, 100);
+            node.emit('message', Buffer.alloc(60), true);
+            (0, chai_1.expect)(node.paused).to.equal(false);
+            node.emit('message', Buffer.alloc(60), true);
+            (0, chai_1.expect)(node.paused, '120 bytes unwritten').to.equal(true);
+            const written = () => viewer.pending.shift()();
+            written();
+            (0, chai_1.expect)(node.paused, '60 bytes unwritten').to.equal(true);
+            written();
+            (0, chai_1.expect)(node.paused, 'all written').to.equal(false);
+        });
+    });
+    describe('openNodeSocket', () => {
+        const actor = { actorId: 'alice', isAdmin: false };
+        it('is null for this server’s own phone, and asks nothing of anyone', () => __awaiter(void 0, void 0, void 0, function* () {
+            const node = yield fakeNode();
+            const socket = yield (0, nodeSocketRelay_1.openNodeSocket)({ udid: 'p', actor, path: 'stream/h264' }, { findDevice: () => __awaiter(void 0, void 0, void 0, function* () { return ({ udid: 'p', host: node.origin, nodeId: 'hub-1' }); }) });
+            (0, chai_1.expect)(socket).to.equal(null);
+            (0, chai_1.expect)(node.seen).to.deep.equal([]);
+        }));
+        it('opens the node’s socket with a ticket of the node’s own, asked for with the hub’s token', () => __awaiter(void 0, void 0, void 0, function* () {
+            const node = yield fakeNode();
+            const socket = yield (0, nodeSocketRelay_1.openNodeSocket)({
+                udid: 'a b',
+                actor,
+                path: 'logcat',
+                query: new URLSearchParams({ levels: 'error', process: 'App' }),
+            }, {
+                findDevice: () => __awaiter(void 0, void 0, void 0, function* () { return ({ udid: 'a b', host: node.origin, nodeId: 'node-1' }); }),
+                controlToken: () => __awaiter(void 0, void 0, void 0, function* () { return 'signed-for-alice'; }),
+            });
+            (0, chai_1.expect)(socket).to.be.instanceOf(ws_1.WebSocket);
+            socket.close();
+            (0, chai_1.expect)(node.seen).to.deep.equal([
+                { url: '/xenon/api/control/a%20b/stream/ticket', hubToken: 'signed-for-alice' },
+                { url: '/xenon/api/control/a%20b/logcat?levels=error&process=App&ticket=node-ticket' },
+            ]);
+        }));
+        it('holds what the node sends first until something reads it', () => __awaiter(void 0, void 0, void 0, function* () {
+            // H.264's config packet and logcat's replay go out the moment the
+            // node's socket opens; lost, the preview never decodes.
+            const node = yield fakeNode({ onSocket: (ws) => ws.send('first frame') });
+            const socket = yield (0, nodeSocketRelay_1.openNodeSocket)({ udid: 'p', actor, path: 'stream/h264' }, {
+                findDevice: () => __awaiter(void 0, void 0, void 0, function* () { return ({ udid: 'p', host: node.origin, nodeId: 'node-1' }); }),
+                controlToken: () => __awaiter(void 0, void 0, void 0, function* () { return null; }),
+            });
+            const up = socket;
+            yield new Promise((r) => setTimeout(r, 100));
+            const first = nextMessage(up);
+            up.resume();
+            (0, chai_1.expect)((yield first).data.toString()).to.equal('first frame');
+            up.close();
+        }));
+        it('a node that refuses the ticket is a refusal, one that can’t be reached is not', () => __awaiter(void 0, void 0, void 0, function* () {
+            const refusing = yield fakeNode({ ticketStatus: 409 });
+            const find = (host) => () => __awaiter(void 0, void 0, void 0, function* () {
+                return ({
+                    udid: 'p',
+                    host,
+                    nodeId: 'node-1',
+                });
+            });
+            let error;
+            yield (0, nodeSocketRelay_1.openNodeSocket)({ udid: 'p', actor, path: 'stream/h264' }, { findDevice: find(refusing.origin), controlToken: () => __awaiter(void 0, void 0, void 0, function* () { return null; }) }).catch((e) => (error = e));
+            (0, chai_1.expect)(error).to.be.instanceOf(nodeSocketRelay_1.NodeSocketRefused);
+            error = undefined;
+            yield (0, nodeSocketRelay_1.openNodeSocket)({ udid: 'p', actor, path: 'stream/h264' }, { findDevice: find('http://127.0.0.1:1'), controlToken: () => __awaiter(void 0, void 0, void 0, function* () { return null; }) }).catch((e) => (error = e));
+            (0, chai_1.expect)(error).to.be.instanceOf(Error);
+            (0, chai_1.expect)(error).to.not.be.instanceOf(nodeSocketRelay_1.NodeSocketRefused);
+        }));
+        it('a cloud provider’s phone is refused without a request', () => __awaiter(void 0, void 0, void 0, function* () {
+            const node = yield fakeNode();
+            let error;
+            yield (0, nodeSocketRelay_1.openNodeSocket)({ udid: 'p', actor, path: 'stream/h264' }, {
+                findDevice: () => __awaiter(void 0, void 0, void 0, function* () { return ({ udid: 'p', host: node.origin, cloud: '{"cloudName":"x"}' }); }),
+            }).catch((e) => (error = e));
+            (0, chai_1.expect)(error).to.be.instanceOf(nodeSocketRelay_1.NodeSocketRefused);
+            (0, chai_1.expect)(node.seen).to.deep.equal([]);
+        }));
+    });
+    describe('the hub’s own sockets', () => {
+        function hubWith(attach) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const server = http_1.default.createServer();
+                attach(server);
+                yield new Promise((resolve) => server.listen(0, '127.0.0.1', resolve));
+                loopbackServersCleanup.push(server);
+                return `ws://127.0.0.1:${server.address().port}`;
+            });
+        }
+        const loopbackServersCleanup = [];
+        afterEach(() => __awaiter(void 0, void 0, void 0, function* () {
+            var _a;
+            for (const s of loopbackServersCleanup.splice(0)) {
+                (_a = s.closeAllConnections) === null || _a === void 0 ? void 0 : _a.call(s);
+                yield new Promise((r) => s.close(r));
+            }
+        }));
+        it('H.264: a node’s phone is relayed from its node, with the ticket’s user', () => __awaiter(void 0, void 0, void 0, function* () {
+            const node = yield fakeNode({ onSocket: (ws) => ws.send(Buffer.from([0, 9, 9])) });
+            const asked = [];
+            const hub = yield hubWith((server) => (0, h264StreamWs_1.attachH264Ws)(server, {
+                redeem: () => __awaiter(void 0, void 0, void 0, function* () { return ({ actorId: 'alice', isAdmin: true }); }),
+                startStream: () => __awaiter(void 0, void 0, void 0, function* () {
+                    throw new Error('not this server’s phone');
+                }),
+                nodeSocket: (udid, who) => __awaiter(void 0, void 0, void 0, function* () {
+                    asked.push({ udid, who });
+                    return nodeSocketAt(`${node.origin.replace('http', 'ws')}/h264`);
+                }),
+            }));
+            const viewer = new ws_1.WebSocket(`${hub}/xenon/api/control/p/stream/h264?ticket=t`);
+            (0, chai_1.expect)((yield nextMessage(viewer)).data).to.deep.equal(Buffer.from([0, 9, 9]));
+            (0, chai_1.expect)(asked).to.deep.equal([{ udid: 'p', who: { actorId: 'alice', isAdmin: true } }]);
+            viewer.close();
+        }));
+        it('H.264: a refusal from the node is 1008, anything else 1011', () => __awaiter(void 0, void 0, void 0, function* () {
+            for (const [thrown, code] of [
+                [new nodeSocketRelay_1.NodeSocketRefused('the node refused the ticket'), 1008],
+                [new Error('ECONNREFUSED'), 1011],
+            ]) {
+                const hub = yield hubWith((server) => (0, h264StreamWs_1.attachH264Ws)(server, {
+                    redeem: () => __awaiter(void 0, void 0, void 0, function* () { return ({ actorId: 'alice' }); }),
+                    startStream: () => __awaiter(void 0, void 0, void 0, function* () {
+                        throw new Error('not this server’s phone');
+                    }),
+                    nodeSocket: () => __awaiter(void 0, void 0, void 0, function* () {
+                        throw thrown;
+                    }),
+                }));
+                const viewer = new ws_1.WebSocket(`${hub}/xenon/api/control/p/stream/h264?ticket=t`);
+                (0, chai_1.expect)((yield closed(viewer)).code).to.equal(code);
+            }
+        }));
+        it('logcat: relayed after this server’s own ownership check, with the filter', () => __awaiter(void 0, void 0, void 0, function* () {
+            const node = yield fakeNode({ onSocket: (ws) => ws.send('{"message":"from the node"}') });
+            const asked = [];
+            let authorized = 0;
+            const hub = yield hubWith((server) => (0, logcatWs_1.attachLogcatWs)(server, {
+                redeem: () => __awaiter(void 0, void 0, void 0, function* () { return ({ actorId: 'alice' }); }),
+                authorize: () => __awaiter(void 0, void 0, void 0, function* () {
+                    authorized++;
+                    return true;
+                }),
+                startStream: () => __awaiter(void 0, void 0, void 0, function* () {
+                    throw new Error('not this server’s phone');
+                }),
+                nodeSocket: (udid, who, filter) => __awaiter(void 0, void 0, void 0, function* () {
+                    asked.push({ udid, filter });
+                    return nodeSocketAt(`${node.origin.replace('http', 'ws')}/logcat`);
+                }),
+            }));
+            const viewer = new ws_1.WebSocket(`${hub}/xenon/api/control/p/logcat?ticket=t&levels=error&process=App`);
+            (0, chai_1.expect)((yield nextMessage(viewer)).data.toString()).to.equal('{"message":"from the node"}');
+            (0, chai_1.expect)(authorized).to.equal(1);
+            (0, chai_1.expect)(asked).to.deep.equal([{ udid: 'p', filter: { levels: ['error'], process: 'App' } }]);
+            viewer.close();
+        }));
+        it('logcat: a phone this server may not show isn’t asked of the node', () => __awaiter(void 0, void 0, void 0, function* () {
+            let asked = 0;
+            const hub = yield hubWith((server) => (0, logcatWs_1.attachLogcatWs)(server, {
+                redeem: () => __awaiter(void 0, void 0, void 0, function* () { return ({ actorId: 'bob' }); }),
+                authorize: () => __awaiter(void 0, void 0, void 0, function* () { return false; }),
+                startStream: () => __awaiter(void 0, void 0, void 0, function* () {
+                    throw new Error('unused');
+                }),
+                nodeSocket: () => __awaiter(void 0, void 0, void 0, function* () {
+                    asked++;
+                    return null;
+                }),
+            }));
+            const viewer = new ws_1.WebSocket(`${hub}/xenon/api/control/p/logcat?ticket=t`);
+            (0, chai_1.expect)((yield closed(viewer)).code).to.equal(1008);
+            (0, chai_1.expect)(asked).to.equal(0);
+        }));
+    });
+});

package/lib/test/unit/omni-vision.spec.js

@@ -19,13 +19,16 @@ const typedi_1 = require("typedi");
 const OmniVisionService_1 = require("../../src/services/omni-vision/OmniVisionService");
 const tesseract_js_1 = __importDefault(require("tesseract.js"));
 const AIService_1 = require("../../src/services/AIService");
+const container_registration_1 = require("../helpers/container-registration");
 describe('OmniVisionService Unit Tests', () => {
     let omniService;
     let mockDriver;
+    let restoreContainer;
     beforeEach(() => {
-        // Reset container to ensure clean state
-        typedi_1.Container.reset();
-        omniService = typedi_1.Container.get(OmniVisionService_1.OmniVisionService);
+        // A fresh service for each test, registered only until it ends.
+        restoreContainer = (0, container_registration_1.saveRegistrations)(OmniVisionService_1.OmniVisionService);
+        omniService = new OmniVisionService_1.OmniVisionService();
+        typedi_1.Container.set(OmniVisionService_1.OmniVisionService, omniService);
         mockDriver = {
             getScreenshot: sinon_1.default.stub().resolves('mock_screenshot_base64'),
             sessionId: 'test_session',
@@ -33,6 +36,7 @@ describe('OmniVisionService Unit Tests', () => {
     });
     afterEach(() => {
         sinon_1.default.restore();
+        restoreContainer();
     });
     const createMockWorker = () => ({
         setParameters: sinon_1.default.stub().resolves(),

package/lib/test/unit/plugin.spec.js

@@ -1,4 +1,37 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 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) {
@@ -12,14 +45,21 @@ Object.defineProperty(exports, "__esModule", { value: true });
 require("reflect-metadata");
 const device_utils_1 = require("../../src/device-utils");
 const chai_1 = require("chai");
-const pluginArgs_1 = require("../../src/data-service/pluginArgs");
 const cliArgs_1 = require("../integration/cliArgs");
 const db_1 = require("../../src/data-service/db");
 const IPluginArgs_1 = require("../../src/interfaces/IPluginArgs");
+const loki_stores_1 = require("../helpers/loki-stores");
 const pluginArgs = IPluginArgs_1.DefaultPluginArgs;
 describe('Device filter tests', () => {
+    // The in-memory stores, also when this file runs on its own: without
+    // NODE_ENV=test the factory handed out the Prisma stores, which are the
+    // developer's ~/.cache/xenon/xenon.db.
+    (0, loki_stores_1.useLokiStores)();
     it('Get Device filters for real device', () => __awaiter(void 0, void 0, void 0, function* () {
-        yield (0, pluginArgs_1.addCLIArgs)(cliArgs_1.serverCliArgs);
+        // Imported here, not at the top: the module keeps the store it gets when
+        // it loads, and only here is that the in-memory one on a file run alone.
+        const { addCLIArgs } = yield Promise.resolve().then(() => __importStar(require('../../src/data-service/pluginArgs')));
+        yield addCLIArgs(cliArgs_1.serverCliArgs);
         (yield db_1.XenonDatabase.CLIArgs)
             .chain()
             .find()
@@ -111,7 +151,8 @@ describe('Device filter tests', () => {
         });
     });
 });
-describe('Pending sessions', () => __awaiter(void 0, void 0, void 0, function* () {
+describe('Pending sessions', () => {
+    (0, loki_stores_1.useLokiStores)();
     beforeEach(() => __awaiter(void 0, void 0, void 0, function* () {
         (yield db_1.XenonDatabase.PendingSessionsModel).removeDataOnly();
     }));
@@ -131,4 +172,4 @@ describe('Pending sessions', () => __awaiter(void 0, void 0, void 0, function* (
         const pendingSessions = (yield db_1.XenonDatabase.PendingSessionsModel).chain().data();
         (0, chai_1.expect)(pendingSessions.length).to.equal(1);
     }));
-}));
+});