ring-client-api 10.0.0 → 11.0.2-beta.0

package/lib/api/streaming/ring-edge-connection.js

@@ -1,13 +1,4 @@
 "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.RingEdgeConnection = void 0;
 const ws_1 = require("ws");
@@ -56,8 +47,8 @@ class RingEdgeConnection extends streaming_connection_base_1.StreamingConnection
                 return;
             }
             this.sendSessionMessage('ping');
-        }), this.pc.onIceCandidate.subscribe((iceCandidate) => __awaiter(this, void 0, void 0, function* () {
-            yield (0, rxjs_1.firstValueFrom)(this.onOfferSent);
+        }), this.pc.onIceCandidate.subscribe(async (iceCandidate) => {
+            await (0, rxjs_1.firstValueFrom)(this.onOfferSent);
             this.sendMessage({
                 method: 'ice',
                 body: {
@@ -76,69 +67,69 @@ class RingEdgeConnection extends streaming_connection_base_1.StreamingConnection
                     mlineindex: 1,
                 },
             });
-        })));
+        }));
     }
-    initiateCall() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { sdp } = yield this.pc.createOffer();
-            this.sendMessage({
-                method: 'live_view',
-                body: {
-                    doorbot_id: this.camera.id,
-                    stream_options: { audio_enabled: true, video_enabled: true },
-                    sdp: sdp.replace('\na=group:BUNDLE 0 1', ''),
-                },
-            });
-            this.onOfferSent.next();
+    async initiateCall() {
+        const { sdp } = await this.pc.createOffer();
+        this.sendMessage({
+            method: 'live_view',
+            body: {
+                doorbot_id: this.camera.id,
+                stream_options: { audio_enabled: true, video_enabled: true },
+                sdp: sdp.replace('\na=group:BUNDLE 0 1', ''),
+            },
         });
+        this.onOfferSent.next();
     }
-    handleMessage(message) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (message.body.doorbot_id !== this.camera.id) {
-                // ignore messages for other cameras
+    async handleMessage(message) {
+        if (message.body.doorbot_id !== this.camera.id) {
+            // ignore messages for other cameras
+            return;
+        }
+        if (['session_created', 'session_started'].includes(message.method) &&
+            'session_id' in message.body &&
+            !this.sessionId) {
+            this.sessionId = message.body.session_id;
+            this.onSessionId.next(this.sessionId);
+        }
+        if (message.body.session_id && message.body.session_id !== this.sessionId) {
+            // ignore messages for other sessions
+            return;
+        }
+        switch (message.method) {
+            case 'session_created':
+            case 'session_started':
+                // session already stored above
                 return;
-            }
-            if (['session_created', 'session_started'].includes(message.method) &&
-                'session_id' in message.body &&
-                !this.sessionId) {
-                this.sessionId = message.body.session_id;
-                this.onSessionId.next(this.sessionId);
-            }
-            if (message.body.session_id && message.body.session_id !== this.sessionId) {
-                // ignore messages for other sessions
+            case 'sdp':
+                await this.pc.acceptAnswer(message.body);
+                this.onCallAnswered.next(message.body.sdp);
                 return;
-            }
-            switch (message.method) {
-                case 'session_created':
-                case 'session_started':
-                    // session already stored above
-                    return;
-                case 'sdp':
-                    yield this.pc.acceptAnswer(message.body);
-                    this.onCallAnswered.next(message.body.sdp);
-                    return;
-                case 'ice':
-                    yield this.pc.addIceCandidate({
-                        candidate: message.body.ice,
-                        sdpMLineIndex: message.body.mlineindex,
-                    });
-                    return;
-                case 'pong':
-                    return;
-                case 'close':
-                    (0, util_1.logError)('Video stream closed');
-                    (0, util_1.logError)(message.body);
-                    this.callEnded();
-                    return;
-            }
-            (0, util_1.logError)('UNKNOWN MESSAGE');
-            (0, util_1.logError)(message);
-        });
+            case 'ice':
+                await this.pc.addIceCandidate({
+                    candidate: message.body.ice,
+                    sdpMLineIndex: message.body.mlineindex,
+                });
+                return;
+            case 'pong':
+                return;
+            case 'close':
+                (0, util_1.logError)('Video stream closed');
+                (0, util_1.logError)(message.body);
+                this.callEnded();
+                return;
+        }
+        (0, util_1.logError)('UNKNOWN MESSAGE');
+        (0, util_1.logError)(message);
     }
     sendSessionMessage(method, body = {}) {
         const message = {
             method,
-            body: Object.assign(Object.assign({}, body), { doorbot_id: this.camera.id, session_id: this.sessionId }),
+            body: {
+                ...body,
+                doorbot_id: this.camera.id,
+                session_id: this.sessionId,
+            },
         };
         if (this.sessionId) {
             // Send immediately if we already have a session id

package/lib/api/streaming/simple-webrtc-session.js

@@ -1,13 +1,4 @@
 "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.SimpleWebRtcSession = void 0;
 const util_1 = require("../util");
@@ -20,43 +11,37 @@ class SimpleWebRtcSession {
         this.restClient = restClient;
         this.sessionId = (0, util_1.generateUuid)();
     }
-    start(sdp) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const response = yield this.restClient.request({
-                method: 'POST',
-                url: liveViewUrl('start'),
-                json: {
-                    session_id: this.sessionId,
-                    device_id: this.camera.id,
-                    sdp,
-                    protocol: 'webrtc',
-                },
-            });
-            return response.sdp;
+    async start(sdp) {
+        const response = await this.restClient.request({
+            method: 'POST',
+            url: liveViewUrl('start'),
+            json: {
+                session_id: this.sessionId,
+                device_id: this.camera.id,
+                sdp,
+                protocol: 'webrtc',
+            },
         });
+        return response.sdp;
     }
-    end() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const resp = yield this.restClient.request({
-                method: 'POST',
-                url: liveViewUrl('end'),
-                json: {
-                    session_id: this.sessionId,
-                },
-            });
-            return resp;
+    async end() {
+        const resp = await this.restClient.request({
+            method: 'POST',
+            url: liveViewUrl('end'),
+            json: {
+                session_id: this.sessionId,
+            },
         });
+        return resp;
     }
-    activateCameraSpeaker() {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.restClient.request({
-                method: 'PATCH',
-                url: liveViewUrl('options'),
-                json: {
-                    session_id: this.sessionId,
-                    actions: ['turn_off_stealth_mode'],
-                },
-            });
+    async activateCameraSpeaker() {
+        await this.restClient.request({
+            method: 'PATCH',
+            url: liveViewUrl('options'),
+            json: {
+                session_id: this.sessionId,
+                actions: ['turn_off_stealth_mode'],
+            },
         });
     }
 }

package/lib/api/streaming/streaming-connection-base.d.ts

@@ -1,7 +1,7 @@
 import { BasicPeerConnection } from './peer-connection';
 import { Subscribed } from '../subscribed';
 import { WebSocket } from 'ws';
-import { RtpPacket } from '@koush/werift';
+import { RtpPacket } from 'werift';
 import { ReplaySubject, Subject } from 'rxjs';
 export interface StreamingConnectionOptions {
     createPeerConnection?: () => BasicPeerConnection;

package/lib/api/streaming/streaming-connection-base.js

@@ -1,13 +1,4 @@
 "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.StreamingConnectionBase = void 0;
 const peer_connection_1 = require("./peer-connection");
@@ -59,23 +50,19 @@ class StreamingConnectionBase extends subscribed_1.Subscribed {
             }
         }));
     }
-    activate() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.activated) {
-                return;
-            }
-            this.activated = true;
-            yield (0, rxjs_1.firstValueFrom)(this.pc.onConnectionState.pipe((0, operators_1.filter)((state) => state === 'connected')));
-            (0, util_1.logInfo)('Activating Session');
-            this.sendSessionMessage('activate_session');
-        });
+    async activate() {
+        if (this.activated) {
+            return;
+        }
+        this.activated = true;
+        await (0, rxjs_1.firstValueFrom)(this.pc.onConnectionState.pipe((0, operators_1.filter)((state) => state === 'connected')));
+        (0, util_1.logInfo)('Activating Session');
+        this.sendSessionMessage('activate_session');
     }
-    activateCameraSpeaker() {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield (0, rxjs_1.firstValueFrom)(this.onCallAnswered);
-            this.sendSessionMessage('camera_options', {
-                stealth_mode: false,
-            });
+    async activateCameraSpeaker() {
+        await (0, rxjs_1.firstValueFrom)(this.onCallAnswered);
+        this.sendSessionMessage('camera_options', {
+            stealth_mode: false,
         });
     }
     sendMessage(message) {

package/lib/api/streaming/streaming-session.d.ts

@@ -1,4 +1,4 @@
-import { RtpPacket } from '@koush/werift';
+import { RtpPacket } from 'werift';
 import { ReplaySubject, Subject } from 'rxjs';
 import { RingEdgeConnection } from './ring-edge-connection';
 import { WebrtcConnection } from './webrtc-connection';
@@ -15,6 +15,7 @@ export declare class StreamingSession extends Subscribed {
     private readonly camera;
     private connection;
     readonly onCallEnded: ReplaySubject<void>;
+    private readonly onUsingOpus;
     readonly onVideoRtp: Subject<RtpPacket>;
     readonly onAudioRtp: Subject<RtpPacket>;
     private readonly audioSplitter;

package/lib/api/streaming/streaming-session.js

@@ -1,13 +1,4 @@
 "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.StreamingSession = void 0;
 const camera_utils_1 = require("@homebridge/camera-utils");
@@ -30,6 +21,7 @@ class StreamingSession extends subscribed_1.Subscribed {
         this.camera = camera;
         this.connection = connection;
         this.onCallEnded = new rxjs_1.ReplaySubject(1);
+        this.onUsingOpus = new rxjs_1.ReplaySubject(1);
         this.onVideoRtp = new rxjs_1.Subject();
         this.onAudioRtp = new rxjs_1.Subject();
         this.audioSplitter = new camera_utils_1.RtpSplitter();
@@ -39,80 +31,74 @@ class StreamingSession extends subscribed_1.Subscribed {
         this.bindToConnection(connection);
     }
     bindToConnection(connection) {
-        this.addSubscriptions(connection.onAudioRtp.subscribe(this.onAudioRtp), connection.onVideoRtp.subscribe(this.onVideoRtp));
+        this.addSubscriptions(connection.onAudioRtp.subscribe(this.onAudioRtp), connection.onVideoRtp.subscribe(this.onVideoRtp), connection.onCallAnswered.subscribe((sdp) => {
+            this.onUsingOpus.next(sdp.toLocaleLowerCase().includes(' opus/'));
+        }));
     }
-    activate() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.activated) {
-                return;
-            }
-            this.activated = true;
-            yield this.connection.activate();
-        });
+    async activate() {
+        if (this.activated) {
+            return;
+        }
+        this.activated = true;
+        await this.connection.activate();
     }
-    activateCameraSpeaker() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.cameraSpeakerActivated) {
-                return;
-            }
-            this.cameraSpeakerActivated = true;
-            yield this.connection.activateCameraSpeaker();
-        });
+    async activateCameraSpeaker() {
+        if (this.cameraSpeakerActivated) {
+            return;
+        }
+        this.cameraSpeakerActivated = true;
+        await this.connection.activateCameraSpeaker();
     }
-    reservePort(bufferPorts = 0) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const ports = yield (0, camera_utils_1.reservePorts)({ count: bufferPorts + 1 });
-            return ports[0];
-        });
+    async reservePort(bufferPorts = 0) {
+        const ports = await (0, camera_utils_1.reservePorts)({ count: bufferPorts + 1 });
+        return ports[0];
     }
-    startTranscoding(ffmpegOptions) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const videoPort = yield this.reservePort(1), audioPort = yield this.reservePort(1), transcodeVideoStream = ffmpegOptions.video !== false, ffmpegInputArguments = [
-                '-hide_banner',
-                '-protocol_whitelist',
-                'pipe,udp,rtp,file,crypto',
-                '-acodec',
-                'libopus',
-                '-f',
-                'sdp',
-                ...(ffmpegOptions.input || []),
-                '-i',
-                'pipe:',
-            ], ringSdp = yield (0, rxjs_1.firstValueFrom)(this.connection.onCallAnswered), inputSdp = getCleanSdp(ringSdp, transcodeVideoStream)
-                .replace(/m=audio \d+/, `m=audio ${audioPort}`)
-                .replace(/m=video \d+/, `m=video ${videoPort}`), ff = new camera_utils_1.FfmpegProcess({
-                ffmpegArgs: ffmpegInputArguments.concat(...(ffmpegOptions.audio || ['-acodec', 'aac']), ...(transcodeVideoStream
-                    ? ffmpegOptions.video || ['-vcodec', 'copy']
-                    : []), ...(ffmpegOptions.output || [])),
-                ffmpegPath: (0, ffmpeg_1.getFfmpegPath)(),
-                exitCallback: () => this.callEnded(),
-                logLabel: `From Ring (${this.camera.name})`,
-                logger: {
-                    error: util_1.logError,
-                    info: util_1.logDebug,
-                },
+    async startTranscoding(ffmpegOptions) {
+        const videoPort = await this.reservePort(1), audioPort = await this.reservePort(1), transcodeVideoStream = ffmpegOptions.video !== false, ringSdp = await (0, rxjs_1.firstValueFrom)(this.connection.onCallAnswered), usingOpus = await (0, rxjs_1.firstValueFrom)(this.onUsingOpus), ffmpegInputArguments = [
+            '-hide_banner',
+            '-protocol_whitelist',
+            'pipe,udp,rtp,file,crypto',
+            // Ring will answer with either opus or pcmu
+            ...(usingOpus ? ['-acodec', 'libopus'] : []),
+            '-f',
+            'sdp',
+            ...(ffmpegOptions.input || []),
+            '-i',
+            'pipe:',
+        ], inputSdp = getCleanSdp(ringSdp, transcodeVideoStream)
+            .replace(/m=audio \d+/, `m=audio ${audioPort}`)
+            .replace(/m=video \d+/, `m=video ${videoPort}`), ff = new camera_utils_1.FfmpegProcess({
+            ffmpegArgs: ffmpegInputArguments.concat(...(ffmpegOptions.audio || ['-acodec', 'aac']), ...(transcodeVideoStream
+                ? ffmpegOptions.video || ['-vcodec', 'copy']
+                : []), ...(ffmpegOptions.output || [])),
+            ffmpegPath: (0, ffmpeg_1.getFfmpegPath)(),
+            exitCallback: () => this.callEnded(),
+            logLabel: `From Ring (${this.camera.name})`,
+            logger: {
+                error: util_1.logError,
+                info: util_1.logDebug,
+            },
+        });
+        this.addSubscriptions(this.onAudioRtp
+            .pipe((0, operators_1.concatMap)((rtp) => {
+            return this.audioSplitter.send(rtp.serialize(), {
+                port: audioPort,
             });
-            this.addSubscriptions(this.onAudioRtp
+        }))
+            .subscribe());
+        if (transcodeVideoStream) {
+            this.addSubscriptions(this.onVideoRtp
                 .pipe((0, operators_1.concatMap)((rtp) => {
-                return this.audioSplitter.send(rtp.serialize(), {
-                    port: audioPort,
+                return this.videoSplitter.send(rtp.serialize(), {
+                    port: videoPort,
                 });
             }))
                 .subscribe());
-            if (transcodeVideoStream) {
-                this.addSubscriptions(this.onVideoRtp
-                    .pipe((0, operators_1.concatMap)((rtp) => {
-                    return this.videoSplitter.send(rtp.serialize(), {
-                        port: videoPort,
-                    });
-                }))
-                    .subscribe());
-            }
-            this.onCallEnded.subscribe(() => ff.stop());
-            ff.writeStdin(inputSdp);
-            // Activate the stream now that ffmpeg is ready to receive
-            yield this.activate();
-        });
+        }
+        this.onCallEnded.subscribe(() => ff.stop());
+        ff.writeStdin(inputSdp);
+        // Activate the stream now that ffmpeg is ready to receive
+        await this.activate();
     }
     callEnded() {
         this.unsubscribe();

package/lib/api/streaming/webrtc-connection.js

@@ -1,13 +1,4 @@
 "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.WebrtcConnection = void 0;
 const ws_1 = require("ws");
@@ -32,29 +23,30 @@ class WebrtcConnection extends streaming_connection_base_1.StreamingConnectionBa
             (0, util_1.logDebug)(`WebSocket connected for ${camera.name}`);
         }));
     }
-    handleMessage(message) {
-        return __awaiter(this, void 0, void 0, function* () {
-            switch (message.method) {
-                case 'sdp':
-                    const answer = yield this.pc.createAnswer(message);
-                    this.sendSessionMessage('sdp', answer);
-                    this.onCallAnswered.next(message.sdp);
-                    this.sendSessionMessage('stream_options', {
-                        audio_enabled: true,
-                        video_enabled: true,
-                    });
-                    return;
-                case 'ice':
-                    yield this.pc.addIceCandidate({
-                        candidate: message.ice,
-                        sdpMLineIndex: message.mlineindex,
-                    });
-                    return;
-            }
-        });
+    async handleMessage(message) {
+        switch (message.method) {
+            case 'sdp':
+                const answer = await this.pc.createAnswer(message);
+                this.sendSessionMessage('sdp', answer);
+                this.onCallAnswered.next(message.sdp);
+                this.sendSessionMessage('stream_options', {
+                    audio_enabled: true,
+                    video_enabled: true,
+                });
+                return;
+            case 'ice':
+                await this.pc.addIceCandidate({
+                    candidate: message.ice,
+                    sdpMLineIndex: message.mlineindex,
+                });
+                return;
+        }
     }
     sendSessionMessage(method, body = {}) {
-        this.sendMessage(Object.assign(Object.assign({}, body), { method }));
+        this.sendMessage({
+            ...body,
+            method,
+        });
     }
 }
 exports.WebrtcConnection = WebrtcConnection;

package/lib/api/util.js

@@ -1,13 +1,4 @@
 "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 };
 };
@@ -63,39 +54,35 @@ function generateUuid(seed) {
     return (0, uuid_1.v4)();
 }
 exports.generateUuid = generateUuid;
-function getHardwareId(systemId) {
-    return __awaiter(this, void 0, void 0, function* () {
-        if (systemId) {
-            return generateUuid(systemId);
-        }
-        const timeoutValue = '-1', { os: id } = yield Promise.race([
-            (0, systeminformation_1.uuid)(),
-            delay(5000).then(() => ({ os: timeoutValue })),
-        ]);
-        if (id === timeoutValue) {
-            logError('Request for system uuid timed out.  Falling back to random session id');
-            return (0, uuid_1.v4)();
-        }
-        if (id === '-') {
-            // default value set by systeminformation if it can't find a real value
-            logError('Unable to get system uuid.  Falling back to random session id');
-            return (0, uuid_1.v4)();
-        }
-        return generateUuid(id);
-    });
+async function getHardwareId(systemId) {
+    if (systemId) {
+        return generateUuid(systemId);
+    }
+    const timeoutValue = '-1', { os: id } = await Promise.race([
+        (0, systeminformation_1.uuid)(),
+        delay(5000).then(() => ({ os: timeoutValue })),
+    ]);
+    if (id === timeoutValue) {
+        logError('Request for system uuid timed out.  Falling back to random session id');
+        return (0, uuid_1.v4)();
+    }
+    if (id === '-') {
+        // default value set by systeminformation if it can't find a real value
+        logError('Unable to get system uuid.  Falling back to random session id');
+        return (0, uuid_1.v4)();
+    }
+    return generateUuid(id);
 }
 exports.getHardwareId = getHardwareId;
-function requestInput(question) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const lineReader = (0, readline_1.createInterface)({
-            input: process.stdin,
-            output: process.stdout,
-        }), answer = yield new Promise((resolve) => {
-            lineReader.question(question, resolve);
-        });
-        lineReader.close();
-        return answer.trim();
+async function requestInput(question) {
+    const lineReader = (0, readline_1.createInterface)({
+        input: process.stdin,
+        output: process.stdout,
+    }), answer = await new Promise((resolve) => {
+        lineReader.question(question, resolve);
     });
+    lineReader.close();
+    return answer.trim();
 }
 exports.requestInput = requestInput;
 function stringify(data) {