ring-client-api 11.7.5 → 11.7.6

package/README.md

@@ -11,6 +11,10 @@ the [Ring Alarm System](https://shop.ring.com/pages/security-system),
 and third party devices that connect to the Ring Alarm System.
 Built to support the [homebridge-ring Plugin](../homebridge-ring)
 
+## Troubleshooting Issues
+
+If you are having issues, please look for related articles in the [wiki](https://github.com/dgreif/ring/wiki) and search existing [Issues](https://github.com/dgreif/ring/issues) before opening a new Issue/Discussion
+
 ## Installation
 
 `npm i ring-client-api`

package/lib/api.js

@@ -127,14 +127,18 @@ class RingApi extends subscribed_1.Subscribed {
             senderId: '876313859327', // for Ring android app.  703521446232 for ring-site
         }), devicesById = {}, sendToDevice = (id, notification) => {
             devicesById[id]?.processPushNotification(notification);
-        };
+        }, onPushNotificationToken = new rxjs_1.Subject();
         for (const camera of cameras) {
             devicesById[camera.id] = camera;
         }
         for (const intercom of intercoms) {
             devicesById[intercom.id] = intercom;
         }
-        pushReceiver.onCredentialsChanged(async ({ newCredentials: { fcm: { token }, }, }) => {
+        pushReceiver.onCredentialsChanged(({ newCredentials: { fcm: { token }, }, }) => onPushNotificationToken.next(token));
+        this.addSubscriptions((0, rxjs_1.combineLatest)([
+            onPushNotificationToken,
+            this.restClient.onSession, // combined but not used here, just to trigger another request when session is updated
+        ]).subscribe(async ([token]) => {
             try {
                 await this.restClient.request({
                     url: (0, rest_client_1.clientApi)('device'),
@@ -154,7 +158,7 @@ class RingApi extends subscribed_1.Subscribed {
             catch (e) {
                 (0, util_1.logError)(e);
             }
-        });
+        }));
         pushReceiver.onNotification(({ message }) => {
             const dataJson = message.data?.gcmData;
             try {
@@ -236,6 +240,7 @@ class RingApi extends subscribed_1.Subscribed {
             (0, util_1.logError)(e);
         });
         this.restClient.clearTimeouts();
+        (0, util_1.clearTimeouts)();
     }
 }
 exports.RingApi = RingApi;

package/lib/rest-client.d.ts

@@ -36,6 +36,7 @@ export declare class RingRestClient {
         oldRefreshToken?: string | undefined;
         newRefreshToken: string;
     }>;
+    onSession: ReplaySubject<SessionResponse>;
     readonly baseSessionMetadata: {
         api_version: number;
         device_model: string;

package/lib/rest-client.js

@@ -94,6 +94,7 @@ class RingRestClient {
         this.sessionPromise = undefined;
         this.using2fa = false;
         this.onRefreshTokenUpdated = new rxjs_1.ReplaySubject(1);
+        this.onSession = new rxjs_1.ReplaySubject(1);
         this.baseSessionMetadata = {
             api_version: apiVersion,
             device_model: this.authOptions.controlCenterDisplayName ?? 'ring-client-api',
@@ -161,6 +162,10 @@ class RingRestClient {
                     responseError.startsWith('Verification Code')) // invalid 2fa code entered
             ) {
                 this.using2fa = true;
+                if (response.statusCode === 400) {
+                    this.promptFor2fa = 'Invalid 2fa code entered.  Please try again.';
+                    throw new Error(responseError);
+                }
                 if ('tsv_state' in responseData) {
                     const { tsv_state, phone } = responseData, prompt = tsv_state === 'totp'
                         ? 'from your authenticator app'
@@ -205,7 +210,9 @@ class RingRestClient {
     getSession() {
         return this.authPromise.then(async (authToken) => {
             try {
-                return await this.fetchNewSession(authToken);
+                const session = await this.fetchNewSession(authToken);
+                this.onSession.next(session);
+                return session;
             }
             catch (e) {
                 const response = e.response || {};
@@ -232,8 +239,20 @@ class RingRestClient {
     }
     refreshSession() {
         this.sessionPromise = this.getSession();
+        this.sessionPromise.finally(() => {
+            // Refresh the session every 12 hours
+            // This is needed to keep the session alive for users outside the US, due to Data Residency laws
+            // We believe Ring is clearing the session info after ~24 hours, which breaks Push Notifications
+            const timeout = setTimeout(() => {
+                this.refreshSession();
+            }, 12 * 60 * 60 * 1000); // 12 hours
+            this.timeouts.push(timeout);
+        });
     }
     async request(options) {
+        if (!this.sessionPromise) {
+            this.refreshSession();
+        }
         const hardwareId = await this.hardwareIdPromise, url = options.url, initialSessionPromise = this.sessionPromise;
         try {
             await initialSessionPromise;

package/lib/test/rest-client.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/test/rest-client.spec.js

@@ -0,0 +1,237 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const msw_1 = require("msw");
+const node_1 = require("msw/node");
+const rest_client_1 = require("../rest-client");
+const util_1 = require("../util");
+const rxjs_1 = require("rxjs");
+let sessionCreatedCount = 0, client;
+const email = 'some@one.com', password = 'abc123!', phone = '+1xxxxxxxx89', twoFactorAuthCode = '123456', hardwareIdPromise = (0, util_1.getHardwareId)(), accessToken = 'ey__accees_token', secondAccessToken = 'ey__second_accees_token', refreshToken = 'ey__refresh_token', secondRefreshToken = 'ey__second_refresh_token', thirdRefreshToken = 'ey__third_refresh_token', server = (0, node_1.setupServer)(msw_1.rest.post('https://oauth.ring.com/oauth/token', async (req, res, ctx) => {
+    const body = await req.json();
+    if (req.headers.get('2fa-support') !== 'true' ||
+        req.headers.get('User-Agent') !== 'android:com.ringapp' ||
+        req.headers.get('hardware_id') !== (await hardwareIdPromise)) {
+        return res(ctx.status(400), ctx.json({
+            code: 1,
+            error: 'Invalid auth headers: ' +
+                JSON.stringify(req.headers.raw(), null, 2),
+        }));
+    }
+    if (body.grant_type === 'refresh_token') {
+        if (body.refresh_token === refreshToken) {
+            // Valid refresh token
+            return res(ctx.status(200), ctx.json({
+                access_token: accessToken,
+                expires_in: 3600,
+                refresh_token: secondRefreshToken,
+                scope: 'client',
+                token_type: 'Bearer',
+            }));
+        }
+        if (body.refresh_token === secondRefreshToken) {
+            // Valid refresh token
+            return res(ctx.status(200), ctx.json({
+                access_token: secondAccessToken,
+                expires_in: 3600,
+                refresh_token: thirdRefreshToken,
+                scope: 'client',
+                token_type: 'Bearer',
+            }));
+        }
+        // Invalid refresh token
+        return res(ctx.status(401), ctx.json({
+            error: 'invalid_grant',
+            error_description: 'token is invalid or does not exists',
+        }));
+    }
+    if (body.grant_type !== 'password' ||
+        body.client_id !== 'ring_official_android' ||
+        body.scope !== 'client') {
+        return res(ctx.status(400), ctx.json({
+            code: 1,
+            error: 'Invalid auth request: ' + JSON.stringify(body),
+        }));
+    }
+    if (body.username !== email || body.password !== password) {
+        // Wrong username or password
+        return res(ctx.status(401), ctx.json({
+            error: 'access_denied',
+            error_description: 'invalid user credentials',
+        }));
+    }
+    if (req.headers.get('2fa-code') &&
+        req.headers.get('2fa-code') !== twoFactorAuthCode) {
+        // Wrong 2fa code
+        return res(ctx.status(400), ctx.json({
+            err_msg: 'bad request response from dependency service',
+            error: 'Verification Code is invalid or expired',
+        }));
+    }
+    if (req.headers.get('2fa-code') === twoFactorAuthCode) {
+        // Successfull login with correct 2fa code
+        return res(ctx.json({
+            access_token: accessToken,
+            expires_in: 3600,
+            refresh_token: refreshToken,
+            scope: 'client',
+            token_type: 'Bearer',
+            responseTimestamp: Date.now(),
+        }));
+    }
+    // 2fa code not provided, so return the 2fa prompt
+    return res(ctx.status(412), ctx.json({
+        next_time_in_secs: 60,
+        phone,
+        tsv_state: 'sms',
+    }));
+}), msw_1.rest.post('https://api.ring.com/clients_api/session', async (req, res, ctx) => {
+    const authHeader = req.headers.get('Authorization');
+    if (authHeader !== `Bearer ${accessToken}` &&
+        authHeader !== `Bearer ${secondAccessToken}`) {
+        // Invalid access token used
+        return res(ctx.status(401));
+    }
+    const body = await req.json();
+    if (body.device.hardware_id !== (await (0, util_1.getHardwareId)()) ||
+        body.device.metadata.api_version !== 11 ||
+        body.device.metadata.device_model !== 'ring-client-api' ||
+        body.device.os !== 'android') {
+        return res(ctx.status(400), ctx.body('Bad session request: ' + JSON.stringify(body, null, 2)));
+    }
+    // Fake a response from the session endpoint, incrementing the sessionCreatedCount
+    sessionCreatedCount++;
+    return res(ctx.json({
+        profile: {
+            id: 1234,
+        },
+    }));
+}));
+beforeEach(() => {
+    sessionCreatedCount = 0;
+});
+beforeAll(() => {
+    // Establish requests interception layer before all tests.
+    server.listen();
+});
+afterAll(() => {
+    // Clean up after all tests are done, preventing this
+    // interception layer from affecting irrelevant tests.
+    server.close();
+});
+afterEach(() => {
+    client.clearTimeouts();
+    (0, util_1.clearTimeouts)();
+});
+describe('getAuth', () => {
+    test('It should throw and set the 2fa prompt', async () => {
+        client = new rest_client_1.RingRestClient({
+            password,
+            email,
+        });
+        await expect(() => client.getAuth()).rejects.toThrow('Your Ring account is configured to use 2-factor authentication (2fa).  See https://github.com/dgreif/ring/wiki/Refresh-Tokens for details.');
+        expect(client.promptFor2fa).toEqual(`Please enter the code sent to ${phone} via sms`);
+        expect(client.using2fa).toEqual(true);
+    });
+    test('It should accept a 2fa code', async () => {
+        client = new rest_client_1.RingRestClient({
+            password,
+            email,
+        });
+        // ignore the first reject, it's tested above
+        await expect(() => client.getAuth()).rejects.toThrow();
+        // call getAuth again with the 2fa code, which should succeed
+        const auth = await client.getAuth(twoFactorAuthCode);
+        expect(auth).toMatchObject({
+            access_token: accessToken,
+            refresh_token: refreshToken,
+        });
+        expect(client.refreshToken).toEqual(refreshToken);
+    });
+    test('it should handle invalid credentials', async () => {
+        client = new rest_client_1.RingRestClient({
+            password: 'incorrect password',
+            email,
+        });
+        await expect(() => client.getAuth()).rejects.toThrow('Failed to fetch oauth token from Ring. Verify that your email and password are correct. (error: access_denied)');
+    });
+    test('it should handle invalid 2fa code', async () => {
+        client = new rest_client_1.RingRestClient({
+            password,
+            email,
+        });
+        // ignore the first reject, it's tested above
+        await expect(() => client.getAuth()).rejects.toThrow();
+        // call getAuth again with an invalid 2fa code, which should fail
+        await expect(() => client.getAuth('invalid 2fa code')).rejects.toThrow('Verification Code is invalid or expired');
+        expect(client.promptFor2fa).toEqual('Invalid 2fa code entered.  Please try again.');
+    });
+    test('it should establish a valid auth token with a valid refresh token', async () => {
+        client = new rest_client_1.RingRestClient({
+            refreshToken,
+        });
+        expect(await client.getCurrentAuth()).toMatchObject({
+            access_token: accessToken,
+            refresh_token: secondRefreshToken,
+        });
+        expect(client.refreshToken).toEqual(secondRefreshToken);
+    });
+    test('it should emit an event when a new refresh token is created', async () => {
+        client = new rest_client_1.RingRestClient({
+            refreshToken,
+        });
+        const refreshedPromise = (0, rxjs_1.firstValueFrom)(client.onRefreshTokenUpdated), auth = await client.getAuth();
+        expect(auth).toMatchObject({
+            access_token: accessToken,
+            refresh_token: secondRefreshToken,
+        });
+        expect(await refreshedPromise).toEqual({
+            oldRefreshToken: refreshToken,
+            newRefreshToken: secondRefreshToken,
+        });
+    });
+});
+describe('fetch', () => {
+    let invalidateFirstAccessToken = false;
+    beforeEach(() => {
+        invalidateFirstAccessToken = false;
+        server.use(msw_1.rest.get('https://api.ring.com/devices/v1/locations', (req, res, ctx) => {
+            const authHeader = req.headers.get('Authorization');
+            if (invalidateFirstAccessToken &&
+                authHeader === `Bearer ${accessToken}`) {
+                // Original access token used, but no longer valid
+                return res(ctx.status(401));
+            }
+            if (authHeader !== `Bearer ${accessToken}` &&
+                authHeader !== `Bearer ${secondAccessToken}`) {
+                // Invalid access token used
+                return res(ctx.status(401));
+            }
+            if (sessionCreatedCount === 0) {
+                // eslint-disable-next-line no-console
+                console.error('Request received before session was created');
+                // Session not created yet
+                return res(ctx.status(404), ctx.text('Session not created yet'));
+            }
+            return res(ctx.json([]));
+        }));
+    });
+    it('should include the auth token as a header', async () => {
+        client = new rest_client_1.RingRestClient({
+            refreshToken,
+        });
+        const response = await client.request({
+            url: 'https://api.ring.com/devices/v1/locations',
+        });
+        expect(response).toEqual([]);
+    });
+    it('should fetch a new auth token if the first is no longer valid', async () => {
+        client = new rest_client_1.RingRestClient({
+            refreshToken,
+        });
+        invalidateFirstAccessToken = true;
+        const response = await client.request({
+            url: 'https://api.ring.com/devices/v1/locations',
+        });
+        expect(response).toEqual([]);
+    });
+});

package/lib/util.d.ts

@@ -2,6 +2,7 @@ interface Logger {
     logInfo: (...message: string[]) => void;
     logError: (message: string) => void;
 }
+export declare function clearTimeouts(): void;
 export declare function delay(milliseconds: number): Promise<unknown>;
 export declare function logDebug(message: any): void;
 export declare function logInfo(...message: any[]): void;

package/lib/util.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.randomString = exports.randomInteger = exports.mapAsync = exports.stringify = exports.requestInput = exports.getHardwareId = exports.generateUuid = exports.enableDebug = exports.useLogger = exports.logError = exports.logInfo = exports.logDebug = exports.delay = void 0;
+exports.randomString = exports.randomInteger = exports.mapAsync = exports.stringify = exports.requestInput = exports.getHardwareId = exports.generateUuid = exports.enableDebug = exports.useLogger = exports.logError = exports.logInfo = exports.logDebug = exports.delay = exports.clearTimeouts = void 0;
 const debug_1 = __importDefault(require("debug"));
 const colors_1 = require("colors");
 const readline_1 = require("readline");
@@ -19,9 +19,20 @@ let logger = {
         debugLogger((0, colors_1.red)(message));
     },
 }, debugEnabled = false;
+const timeouts = new Set();
+function clearTimeouts() {
+    timeouts.forEach((timeout) => {
+        clearTimeout(timeout);
+    });
+}
+exports.clearTimeouts = clearTimeouts;
 function delay(milliseconds) {
     return new Promise((resolve) => {
-        setTimeout(resolve, milliseconds);
+        const timeout = setTimeout(() => {
+            timeouts.delete(timeout);
+            resolve(undefined);
+        }, milliseconds);
+        timeouts.add(timeout);
     });
 }
 exports.delay = delay;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ring-client-api",
-  "version": "11.7.5",
+  "version": "11.7.6",
   "description": "Unofficial API for Ring doorbells, cameras, security alarm system and smart lighting",
   "main": "lib/index.js",
   "exports": {
@@ -25,6 +25,7 @@
     "colors": "1.4.0",
     "debug": "^4.3.4",
     "got": "^11.8.5",
+    "msw": "^1.2.1",
     "rxjs": "^7.8.0",
     "socket.io-client": "^2.5.0",
     "systeminformation": "^5.17.12",