@dronedeploy/rocos-js-sdk 2.6.1 → 3.0.0-alpha.20

package/services/SpotProvisioningServiceNode.d.ts

@@ -2,7 +2,7 @@
 import { IBaseService, IRocosSDKConfig, RocosError } from '../models';
 import { BaseServiceAbstract } from './BaseServiceAbstract';
 import { Timezone } from '../constants/timezones';
-declare type SpotImageTag = 'stable' | 'dev' | 'unstable';
+type SpotImageTag = 'stable' | 'dev' | 'unstable';
 export declare class SpotProvisioningServiceNode extends BaseServiceAbstract implements IBaseService {
     constructor(config: IRocosSDKConfig);
     getStatus(): boolean;

package/services/SpotProvisioningServiceNode.js

@@ -1,34 +1,35 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SpotProvisioningServiceNode = void 0;
-const models_1 = require("../models");
-const api_1 = require("../constants/api");
-const BaseServiceAbstract_1 = require("./BaseServiceAbstract");
-const RocosLogger_1 = require("../logger/RocosLogger");
-const RocosStore_1 = require("../store/RocosStore");
-const formatServiceUrl_1 = require("../helpers/formatServiceUrl");
-class SpotProvisioningServiceNode extends BaseServiceAbstract_1.BaseServiceAbstract {
+import { RocosError, errorCodes } from '../models';
+import { API_SPOTTY_URL } from '../constants/api';
+import { BaseServiceAbstract } from './BaseServiceAbstract';
+import { RocosLogger } from '../logger/RocosLogger';
+import { RocosStore } from '../store/RocosStore';
+import { formatServiceUrl } from '../helpers/formatServiceUrl';
+export class SpotProvisioningServiceNode extends BaseServiceAbstract {
     constructor(config) {
         super(config);
-        this.logger = RocosLogger_1.RocosLogger.getInstance(`SpotService(${this.config.url})`);
+        this.logger = RocosLogger.getInstance(`SpotService(${this.config.url})`);
     }
     getStatus() {
         return true;
     }
     getError(e) {
-        return new models_1.RocosError(e, models_1.errorCodes.SPOT_SERVICE_ERROR);
+        return new RocosError(e, errorCodes.SPOT_SERVICE_ERROR);
     }
     async getSpotCoreImage(projectId, profileId, robot, tag = 'stable', patMetadata, timezone) {
-        const userService = RocosStore_1.RocosStore.getSDKInstance(this.config).getUserService();
+        const userService = RocosStore.getSDKInstance(this.config).getUserService();
         const pat = await userService.createPAT({
             name: `Spot provisioning token for ${robot.callsign}`,
             projectId,
             scope: ['provisioning'],
             robotDefinitionId: profileId,
-            metaData: Object.assign({ defaultRobotDefinitionId: profileId, singleUse: true }, patMetadata),
+            metaData: {
+                defaultRobotDefinitionId: profileId,
+                singleUse: true,
+                ...patMetadata,
+            },
             ttlDays: 90,
         });
-        return this.callPost(formatServiceUrl_1.formatServiceUrl(api_1.API_SPOTTY_URL, { url: this.config.url }, this.config.insecure), {
+        return this.callPost(formatServiceUrl(API_SPOTTY_URL, { url: this.config.url }, this.config.insecure), {
             pat: pat.pat,
             callsign: robot.callsign,
             robotName: robot.name,
@@ -40,4 +41,3 @@ class SpotProvisioningServiceNode extends BaseServiceAbstract_1.BaseServiceAbstr
         });
     }
 }
-exports.SpotProvisioningServiceNode = SpotProvisioningServiceNode;

package/services/StreamService.js

@@ -1,21 +1,18 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.StreamService = void 0;
-const api_1 = require("../constants/api");
-const RocosError_1 = require("../models/RocosError");
-const BaseServiceAbstract_1 = require("./BaseServiceAbstract");
-const RocosLogger_1 = require("../logger/RocosLogger");
-const Stream_1 = require("../models/Stream");
-const StreamSource_1 = require("../models/StreamSource");
-const cleanObject_1 = require("../helpers/cleanObject");
-const formatServiceUrl_1 = require("../helpers/formatServiceUrl");
-class StreamService extends BaseServiceAbstract_1.BaseServiceAbstract {
+import { API_PROJECT_CALLSIGN_STREAM_URL, API_PROJECT_STREAM_CALLSIGN_URL, API_PROJECT_STREAM_DATA_URL, API_PROJECT_STREAM_ID_URL, API_PROJECT_STREAM_URL, API_SOURCE_ID_URL, API_SOURCE_URL, API_TEMPLATE_EXPORTER_URL, } from '../constants/api';
+import { RocosError, errorCodes } from '../models/RocosError';
+import { BaseServiceAbstract } from './BaseServiceAbstract';
+import { RocosLogger } from '../logger/RocosLogger';
+import { Stream } from '../models/Stream';
+import { StreamSource } from '../models/StreamSource';
+import { cleanObject } from '../helpers/cleanObject';
+import { formatServiceUrl } from '../helpers/formatServiceUrl';
+export class StreamService extends BaseServiceAbstract {
     constructor(config) {
         super(config);
-        this.logger = RocosLogger_1.RocosLogger.getInstance(`StreamService(${this.config.url})`);
+        this.logger = RocosLogger.getInstance(`StreamService(${this.config.url})`);
     }
     getError(e) {
-        return new RocosError_1.RocosError(e, RocosError_1.errorCodes.STREAM_SERVICE_ERROR);
+        return new RocosError(e, errorCodes.STREAM_SERVICE_ERROR);
     }
     getStatus() {
         return true;
@@ -28,14 +25,14 @@ class StreamService extends BaseServiceAbstract_1.BaseServiceAbstract {
      */
     // TODO: map the response object
     async create(projectId, stream) {
-        return this.callPost(formatServiceUrl_1.formatServiceUrl(api_1.API_PROJECT_STREAM_URL, { url: this.config.url, projectId }, this.config.insecure), cleanObject_1.cleanObject(new Stream_1.Stream(stream)), `Failed to create stream for ${projectId}.`);
+        return this.callPost(formatServiceUrl(API_PROJECT_STREAM_URL, { url: this.config.url, projectId }, this.config.insecure), cleanObject(new Stream(stream)), `Failed to create stream for ${projectId}.`);
     }
     /**
      * Get streams list by project id.
      */
     async list(projectId) {
-        const data = await this.callGet(formatServiceUrl_1.formatServiceUrl(api_1.API_PROJECT_STREAM_URL, { url: this.config.url, projectId }, this.config.insecure), `Failed to get streams for ${projectId}.`);
-        return data.map((stream) => cleanObject_1.cleanObject(new Stream_1.Stream(stream)));
+        const data = await this.callGet(formatServiceUrl(API_PROJECT_STREAM_URL, { url: this.config.url, projectId }, this.config.insecure), `Failed to get streams for ${projectId}.`);
+        return data.map((stream) => cleanObject(new Stream(stream)));
     }
     /**
      * Get stream information by project id and stream id.
@@ -44,8 +41,8 @@ class StreamService extends BaseServiceAbstract_1.BaseServiceAbstract {
      * @param streamId - Stream Id
      */
     async info(projectId, streamId) {
-        const data = await this.callGet(formatServiceUrl_1.formatServiceUrl(api_1.API_PROJECT_STREAM_ID_URL, { url: this.config.url, projectId, streamId }, this.config.insecure), `Failed to get stream for ${projectId}, streamId ${streamId}.`);
-        return cleanObject_1.cleanObject(new Stream_1.Stream(data));
+        const data = await this.callGet(formatServiceUrl(API_PROJECT_STREAM_ID_URL, { url: this.config.url, projectId, streamId }, this.config.insecure), `Failed to get stream for ${projectId}, streamId ${streamId}.`);
+        return cleanObject(new Stream(data));
     }
     /**
      * Add new data to the stream
@@ -56,13 +53,13 @@ class StreamService extends BaseServiceAbstract_1.BaseServiceAbstract {
      */
     // TODO: map the response object
     async addData(projectId, streamId, sources) {
-        return this.callPut(formatServiceUrl_1.formatServiceUrl(api_1.API_PROJECT_STREAM_DATA_URL, { url: this.config.url, projectId, streamId }, this.config.insecure), { data: sources.map((source) => cleanObject_1.cleanObject(new StreamSource_1.StreamSource(source))) }, `Failed add data to stream for ${projectId}, streamId ${streamId}.`);
+        return this.callPut(formatServiceUrl(API_PROJECT_STREAM_DATA_URL, { url: this.config.url, projectId, streamId }, this.config.insecure), { data: sources.map((source) => cleanObject(new StreamSource(source))) }, `Failed add data to stream for ${projectId}, streamId ${streamId}.`);
     }
     /**
      * Get sources for stream.
      */
     async sources() {
-        return this.callGet(formatServiceUrl_1.formatServiceUrl(api_1.API_SOURCE_URL, { url: this.config.url }, this.config.insecure), 'Failed to get sources for stream.');
+        return this.callGet(formatServiceUrl(API_SOURCE_URL, { url: this.config.url }, this.config.insecure), 'Failed to get sources for stream.');
     }
     /**
      * Get source info
@@ -70,7 +67,7 @@ class StreamService extends BaseServiceAbstract_1.BaseServiceAbstract {
      * @param sourceId - Source Id
      */
     async sourceInfo(sourceId) {
-        return this.callGet(formatServiceUrl_1.formatServiceUrl(api_1.API_SOURCE_ID_URL, { url: this.config.url, sourceId }, this.config.insecure), `Failed add et source info for ${sourceId}.`);
+        return this.callGet(formatServiceUrl(API_SOURCE_ID_URL, { url: this.config.url, sourceId }, this.config.insecure), `Failed add et source info for ${sourceId}.`);
     }
     /**
      * Get streams list of robot
@@ -79,7 +76,7 @@ class StreamService extends BaseServiceAbstract_1.BaseServiceAbstract {
      * @param callsign - Robot's Callsign
      */
     async streamsForRobot(projectId, callsign) {
-        return this.callGet(formatServiceUrl_1.formatServiceUrl(api_1.API_PROJECT_CALLSIGN_STREAM_URL, { url: this.config.url, projectId, callsign }, this.config.insecure), `Failed get streams for ${projectId}, callsign ${callsign}.`);
+        return this.callGet(formatServiceUrl(API_PROJECT_CALLSIGN_STREAM_URL, { url: this.config.url, projectId, callsign }, this.config.insecure), `Failed get streams for ${projectId}, callsign ${callsign}.`);
     }
     /**
      * Bind robot with stream
@@ -90,7 +87,7 @@ class StreamService extends BaseServiceAbstract_1.BaseServiceAbstract {
      */
     // TODO: map the response object
     async bindRobot(projectId, streamId, callsigns) {
-        return this.callPut(formatServiceUrl_1.formatServiceUrl(api_1.API_PROJECT_STREAM_CALLSIGN_URL, { url: this.config.url, projectId, streamId }, this.config.insecure), callsigns, `Failed to bind robot with stream for ${projectId}, streamId ${streamId}.`);
+        return this.callPut(formatServiceUrl(API_PROJECT_STREAM_CALLSIGN_URL, { url: this.config.url, projectId, streamId }, this.config.insecure), callsigns, `Failed to bind robot with stream for ${projectId}, streamId ${streamId}.`);
     }
     /**
      * Unbind robot with stream
@@ -101,7 +98,7 @@ class StreamService extends BaseServiceAbstract_1.BaseServiceAbstract {
      */
     // TODO: map the response object
     async unbindRobot(projectId, streamId, callsigns) {
-        return this.callDelete(formatServiceUrl_1.formatServiceUrl(api_1.API_PROJECT_STREAM_CALLSIGN_URL, { url: this.config.url, projectId, streamId }, this.config.insecure), `Failed to unbind robot with stream for ${projectId}, streamId ${streamId}.`, callsigns);
+        return this.callDelete(formatServiceUrl(API_PROJECT_STREAM_CALLSIGN_URL, { url: this.config.url, projectId, streamId }, this.config.insecure), `Failed to unbind robot with stream for ${projectId}, streamId ${streamId}.`, callsigns);
     }
     /**
      * Remove streams by list
@@ -111,7 +108,7 @@ class StreamService extends BaseServiceAbstract_1.BaseServiceAbstract {
      */
     // TODO: map the response object
     async removeStreams(projectId, streamIds) {
-        return this.callDelete(formatServiceUrl_1.formatServiceUrl(api_1.API_PROJECT_STREAM_URL, { url: this.config.url, projectId }, this.config.insecure), `Failed to remove stream for ${projectId}.`, streamIds);
+        return this.callDelete(formatServiceUrl(API_PROJECT_STREAM_URL, { url: this.config.url, projectId }, this.config.insecure), `Failed to remove stream for ${projectId}.`, streamIds);
     }
     /**
      * Remove stream data by dataIds list
@@ -122,7 +119,7 @@ class StreamService extends BaseServiceAbstract_1.BaseServiceAbstract {
      */
     // TODO: map the response object
     async removeStreamData(projectId, streamId, dataIds) {
-        return this.callDelete(formatServiceUrl_1.formatServiceUrl(api_1.API_PROJECT_STREAM_DATA_URL, { url: this.config.url, projectId, streamId }, this.config.insecure), `Failed to remove streams for ${projectId}, streamId ${streamId}.`, dataIds);
+        return this.callDelete(formatServiceUrl(API_PROJECT_STREAM_DATA_URL, { url: this.config.url, projectId, streamId }, this.config.insecure), `Failed to remove streams for ${projectId}, streamId ${streamId}.`, dataIds);
     }
     /**
      * Remove stream data by ids list
@@ -133,14 +130,13 @@ class StreamService extends BaseServiceAbstract_1.BaseServiceAbstract {
      */
     // TODO: map the response object
     async removeStreamDataByIds(projectId, streamId, ids) {
-        return this.callDelete(formatServiceUrl_1.formatServiceUrl(api_1.API_PROJECT_STREAM_DATA_URL, { url: this.config.url, projectId, streamId }, this.config.insecure), `Failed to remove streams for ${projectId}, streamId ${streamId}.`, ids);
+        return this.callDelete(formatServiceUrl(API_PROJECT_STREAM_DATA_URL, { url: this.config.url, projectId, streamId }, this.config.insecure), `Failed to remove streams for ${projectId}, streamId ${streamId}.`, ids);
     }
     /**
      * Get stream data exporter templates list
      */
     // TODO: map the response object
     async dataExporterTemplates() {
-        return this.callGet(formatServiceUrl_1.formatServiceUrl(api_1.API_TEMPLATE_EXPORTER_URL, { url: this.config.url }, this.config.insecure), 'Failed to get data exporters.');
+        return this.callGet(formatServiceUrl(API_TEMPLATE_EXPORTER_URL, { url: this.config.url }, this.config.insecure), 'Failed to get data exporters.');
     }
 }
-exports.StreamService = StreamService;

package/services/TelemetryService.d.ts

@@ -1,23 +1,11 @@
-import { Observable, Subject } from 'rxjs';
-import { ITelemetrySubscriptionParams, ITelemetrySubscriptions } from '../models/params/ITelemetryParams';
-import { IBaseService } from '../models/IBaseService';
-import { IRocosSDKConfig } from '../models/IRocosSDKConfig';
-import { IRocosTelemetryMessage } from '../models/message/IRocosTelemetryMessage';
-import { IStreamStatusMessage } from '../models/message/IStreamStatusMessage';
-import { ISubscriberStatus } from '../models/ISubscriberStatus';
-import { ITelemetryStream } from '../models/stream/ITelemetryStream';
-import { ITelemetryStreamConfig } from '../models/ITelemetryStreamConfig';
-import { SubscriberStatusEnum } from '../models/SubscriberStatusEnum';
-export declare class TelemetryService implements IBaseService, ISubscriberStatus {
-    private config;
-    private logger;
-    private status;
+import { Observable } from 'rxjs';
+import { CallsignStatus, IRocosSDKConfig, IRocosTelemetryMessage, IStreamStatusMessage, ITelemetryStream, ITelemetryStreamConfig, ITelemetrySubscriptionParams, ITelemetrySubscriptions } from '../models';
+import { BaseStreamService } from './BaseStreamService';
+export declare class TelemetryService extends BaseStreamService<ITelemetryStream, ITelemetryStreamConfig> {
     private statusSubscription;
     private changeStream$;
     private streamStatusSubject$;
-    status$: Subject<SubscriberStatusEnum>;
     constructor(config: IRocosSDKConfig);
-    getStatus(): boolean;
     /**
      * The main method for subscribing to telemetry messages
      *
@@ -38,6 +26,16 @@ export declare class TelemetryService implements IBaseService, ISubscriberStatus
      * @returns An Observable that outputs stream status
      */
     getStatusChanges(): Observable<IStreamStatusMessage>;
-    private initStream;
+    /**
+     * Subscribes to the heartbeat telemetry and checks we receive one at least every 5s
+     * @param projectId
+     * @param callsign
+     * @param heartbeatTimeoutMs optionally override the deadline for heartbeats (in ms). Default 5000ms
+     * @param intervalMs optionally override the interval to check for heartbeats (in ms). Default 2000ms
+     */
+    getRobotStatusChanges(projectId: string, callsign: string, heartbeatTimeoutMs?: number, intervalMs?: number): Observable<CallsignStatus>;
+    protected initStream(stream: ITelemetryStream): Promise<void>;
+    private buildScope;
+    private createStream;
     protected getStream(config: ITelemetryStreamConfig): ITelemetryStream;
 }

package/services/TelemetryService.js

@@ -1,41 +1,31 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TelemetryService = void 0;
-const rxjs_1 = require("rxjs");
-const RocosError_1 = require("../models/RocosError");
-const operators_1 = require("rxjs/operators");
-const CallsignsLookup_1 = require("../models/callsigns/CallsignsLookup");
-const CallsignsEnums_1 = require("../models/callsigns/CallsignsEnums");
-const identifier_1 = require("../constants/identifier");
-const RocosLogger_1 = require("../logger/RocosLogger");
-const RocosStore_1 = require("../store/RocosStore");
-const StreamRegister_1 = require("../api/StreamRegister");
-const SubscriberStatusEnum_1 = require("../models/SubscriberStatusEnum");
-const TelemetryStream_1 = require("../api/streams/telemetry/TelemetryStream");
-const arrayUnique_1 = require("../helpers/arrayUnique");
-const getUniqueId_1 = require("../helpers/getUniqueId");
-class TelemetryService {
+import { BehaviorSubject, catchError, combineLatest, distinctUntilChanged, from, interval, map, mergeAll, of, startWith, } from 'rxjs';
+import { CallsignsLookup, CallsignsLookupType, CallsignStatus, errorCodes, RocosError, SubscriberStatusEnum, } from '../models';
+import { filter, finalize } from 'rxjs/operators';
+import { BaseStreamService } from './BaseStreamService';
+import { IDENTIFIER_NAME_TELEMETRY } from '../constants/identifier';
+import { RocosStore } from '../store/RocosStore';
+import { TelemetryStream } from '../api/streams/telemetry/TelemetryStream';
+import { arrayUnique } from '../helpers/arrayUnique';
+import { getUniqueId } from '../helpers/getUniqueId';
+import { flattenCallsignsLookup } from '../helpers/flattenCallsignsLookup';
+const HEARTBEAT_SOURCE = '/rocos/agent/telemetry/heartbeat';
+const HEARTBEAT_TIMEOUT = 5000; // if no heartbeat within 5 seconds then the robot is considered dead
+export class TelemetryService extends BaseStreamService {
     constructor(config) {
-        this.status = false;
-        this.changeStream$ = new rxjs_1.BehaviorSubject(new Map());
-        this.status$ = new rxjs_1.Subject();
-        this.config = config;
-        this.logger = RocosLogger_1.RocosLogger.getInstance(`TelemetryService(${this.config.url})`);
-        RocosStore_1.RocosStore.getChangeSubject()
-            .pipe(operators_1.filter((message) => {
+        super('TelemetryService', config);
+        this.changeStream$ = new BehaviorSubject(new Map());
+        RocosStore.getChangeSubject()
+            .pipe(filter((message) => {
             return message.type === 'telemetry-subscription' && message.url === this.config.url;
         }))
             .subscribe((msg) => {
             this.changeStream$.next(msg.data);
         });
-        this.streamStatusSubject$ = new rxjs_1.BehaviorSubject({
+        this.streamStatusSubject$ = new BehaviorSubject({
             scope: 'default',
-            status: SubscriberStatusEnum_1.SubscriberStatusEnum.STOPPED,
+            status: SubscriberStatusEnum.STOPPED,
         });
     }
-    getStatus() {
-        return this.status;
-    }
     /**
      * The main method for subscribing to telemetry messages
      *
@@ -44,65 +34,42 @@ class TelemetryService {
      * @returns An Observable that outputs telemetry messages
      */
     subscribe(params) {
-        var _a, _b;
-        const sources = (_a = arrayUnique_1.arrayUnique(params.sources).map((item) => item.trim())) !== null && _a !== void 0 ? _a : [];
-        if (!(params === null || params === void 0 ? void 0 : params.callsigns) && (params === null || params === void 0 ? void 0 : params.query)) {
+        const sources = arrayUnique(params.sources).map((item) => item.trim()) ?? [];
+        if (!params?.callsigns && params?.query) {
             this.logger.error('Error: params need to contain either callsigns or query', params);
-            throw new RocosError_1.RocosError('Params need to contain either callsigns or query.', RocosError_1.errorCodes.TELEMETRY_SERVICE_ERROR);
+            throw new RocosError('Params need to contain either callsigns or query.', errorCodes.TELEMETRY_SERVICE_ERROR);
         }
-        let callsignsLookup = new CallsignsLookup_1.CallsignsLookup([]);
-        if (params === null || params === void 0 ? void 0 : params.callsigns) {
+        let callsignsLookup = new CallsignsLookup([]);
+        if (params?.callsigns) {
             this.logger.info('subscribe with callsigns', params);
-            callsignsLookup = new CallsignsLookup_1.CallsignsLookup(params.callsigns);
+            callsignsLookup = new CallsignsLookup(params.callsigns);
         }
-        else if (params === null || params === void 0 ? void 0 : params.query) {
+        else if (params?.query) {
             this.logger.info('subscribe with query', params);
-            callsignsLookup = new CallsignsLookup_1.CallsignsLookup(params.query);
-        }
-        const scope = (_b = params.scope) !== null && _b !== void 0 ? _b : 'default';
-        const identifier = StreamRegister_1.StreamRegister.getIdentifier(identifier_1.IDENTIFIER_NAME_TELEMETRY, scope);
-        const streamRegister = StreamRegister_1.StreamRegister.getInstance();
-        let stream = streamRegister.getStream(identifier);
-        if (!stream) {
-            stream = this.getStream({
-                url: this.config.url,
-                projectId: params.projectId,
-                callsignsLookup,
-                sources,
-                token: this.config.token,
-                scope,
-                options: this.config.options,
-                port: this.config.port,
-                insecure: this.config.insecure,
-            });
-            // don't wait for these promises, they can be init after startup
-            void streamRegister.addStream(stream);
-            void this.initStream(stream);
-            stream.statusStream$.subscribe((msg) => {
-                this.streamStatusSubject$.next({
-                    scope,
-                    status: msg,
-                });
-            });
+            callsignsLookup = new CallsignsLookup(params.query);
         }
+        // scope is used as a key to generate unique streams
+        // ideally there should be just one concurrent stream opened
+        const scope = this.buildScope(params, callsignsLookup);
+        const callsigns = callsignsLookup.lookupValue;
         const subscriptionParams = {
-            uniqueId: getUniqueId_1.getUniqueId(params.projectId, callsignsLookup, sources, scope),
-            callsigns: callsignsLookup && callsignsLookup.lookupType === CallsignsEnums_1.CallsignsLookupType.List
-                ? callsignsLookup.lookupValue
-                : [],
+            uniqueId: getUniqueId(params.projectId, callsignsLookup, sources, scope),
+            callsigns: callsignsLookup?.lookupType === CallsignsLookupType.List ? callsignsLookup.lookupValue : [],
             sources,
         };
-        stream.addSubscription(subscriptionParams);
-        const callsigns = callsignsLookup.lookupValue;
-        if (!this.statusSubscription) {
-            this.statusSubscription = stream.statusStream$.subscribe((msg) => {
-                this.status = msg === SubscriberStatusEnum_1.SubscriberStatusEnum.STOPPED || msg === SubscriberStatusEnum_1.SubscriberStatusEnum.ALIVE;
-                this.status$.next(msg);
-            });
-        }
-        return rxjs_1.from(stream.messageStream$).pipe(operators_1.filter((message) => {
+        const stream = this.createStream(params.projectId, callsignsLookup, sources, scope).then((stream) => {
+            stream.addSubscription(subscriptionParams);
+            if (!this.statusSubscription) {
+                this.statusSubscription = stream.statusStream$.subscribe((msg) => {
+                    this.status = msg === SubscriberStatusEnum.STOPPED || msg === SubscriberStatusEnum.ALIVE;
+                    this.status$.next(msg);
+                });
+            }
+            return from(stream.messageStream$).pipe(finalize(() => stream?.removeSubscription(subscriptionParams, params.terminateReceiverGroupOnUnsubscribe)));
+        });
+        return from(stream).pipe(mergeAll(), filter((message) => {
             return callsigns.includes(message.callsign) && sources.includes(message.source);
-        }), operators_1.finalize(() => stream === null || stream === void 0 ? void 0 : stream.removeSubscription(subscriptionParams, params.terminateReceiverGroupOnUnsubscribe)));
+        }));
     }
     /**
      * A method to keep track of the current subscriptions
@@ -120,25 +87,68 @@ class TelemetryService {
     getStatusChanges() {
         return this.streamStatusSubject$.asObservable();
     }
-    async initStream(stream) {
-        // an async callback to set the stream token in case one was not set at startup
-        if (!this.config.token) {
-            try {
-                const authService = RocosStore_1.RocosStore.getSDKInstance(this.config).getAuthService();
-                const token = await authService.getToken();
-                if (token === null || token === void 0 ? void 0 : token.value) {
-                    this.config.token = token === null || token === void 0 ? void 0 : token.value;
-                    stream.setToken(this.config.token);
-                }
+    /**
+     * Subscribes to the heartbeat telemetry and checks we receive one at least every 5s
+     * @param projectId
+     * @param callsign
+     * @param heartbeatTimeoutMs optionally override the deadline for heartbeats (in ms). Default 5000ms
+     * @param intervalMs optionally override the interval to check for heartbeats (in ms). Default 2000ms
+     */
+    getRobotStatusChanges(projectId, callsign, heartbeatTimeoutMs = HEARTBEAT_TIMEOUT, intervalMs = 2000) {
+        const startedAt = Date.now();
+        const heartbeatTime$ = this.subscribe({
+            projectId,
+            sources: [HEARTBEAT_SOURCE],
+            callsigns: [callsign],
+        }).pipe(map(() => Date.now()));
+        return combineLatest([heartbeatTime$.pipe(startWith(startedAt)), interval(intervalMs)]).pipe(map(([lastHeartbeat, _]) => {
+            const now = Date.now();
+            // If we haven't received a heartbeat, but we've only just started
+            if (lastHeartbeat === startedAt && now - startedAt <= heartbeatTimeoutMs) {
+                return CallsignStatus.UNKNOWN;
             }
-            catch (e) {
-                this.logger.info('Can not retrieve auth token', e);
+            if (now - lastHeartbeat > heartbeatTimeoutMs) {
+                return CallsignStatus.OFFLINE;
             }
-        }
+            return CallsignStatus.ONLINE;
+        }), startWith(CallsignStatus.UNKNOWN), distinctUntilChanged(), catchError(() => of(CallsignStatus.ERROR)));
+    }
+    async initStream(stream) {
+        await super.initStream(stream);
         stream.init();
     }
+    buildScope(params, callsignsLookup) {
+        // prefix with project id to avoid stream instance to be shared across projects
+        if (params.scope)
+            return `${params.projectId}-${params.scope}`;
+        this.logger.debug(`No scope is set, generating default`);
+        if (callsignsLookup)
+            return `${params.projectId}-default-${flattenCallsignsLookup(callsignsLookup).join()}`;
+        return `${params.projectId}-default`;
+    }
+    async createStream(projectId, callsignsLookup, sources, scope) {
+        const newStream = await this.createStreamFromConfig(IDENTIFIER_NAME_TELEMETRY, {
+            url: this.config.url,
+            projectId,
+            callsignsLookup,
+            sources,
+            token: this.config.token,
+            scope: scope ?? 'default',
+            options: this.config.options,
+            port: this.config.port,
+            insecure: this.config.insecure,
+        });
+        if (!newStream.isNew) {
+            newStream.stream.statusStream$.subscribe((msg) => {
+                this.streamStatusSubject$.next({
+                    scope,
+                    status: msg,
+                });
+            });
+        }
+        return newStream.stream;
+    }
     getStream(config) {
-        return new TelemetryStream_1.TelemetryStream(config);
+        return new TelemetryStream(config);
     }
 }
-exports.TelemetryService = TelemetryService;

package/services/TelemetryService.spec.d.ts

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

package/services/TelemetryService.spec.js

@@ -0,0 +1,37 @@
+import { CallsignStatus } from '../models';
+import { NEVER, delay, from, lastValueFrom, take, throwError } from 'rxjs';
+import { TelemetryService } from './TelemetryService';
+describe('TelemetryService', () => {
+    describe('getRobotStatusChanges', () => {
+        it('should emit unknown to begin with', async () => {
+            const service = new TelemetryService({ url: '', token: '' });
+            // Mock 5 heartbeat messages
+            jest.spyOn(service, 'subscribe').mockReturnValue(NEVER);
+            const lastValue = await lastValueFrom(service.getRobotStatusChanges('project', 'callsign').pipe(take(1)));
+            expect(lastValue).toEqual(CallsignStatus.UNKNOWN);
+        });
+        it('should emit online if the robot emits a heartbeat', async () => {
+            const service = new TelemetryService({ url: '', token: '' });
+            // Mock 5 heartbeat messages
+            jest
+                .spyOn(service, 'subscribe')
+                .mockReturnValue(from([0, 1, 2, 3, 4]).pipe(delay(100)));
+            const lastValue = await lastValueFrom(service.getRobotStatusChanges('project', 'callsign', 1000, 10).pipe(take(2)));
+            expect(lastValue).toEqual(CallsignStatus.ONLINE);
+        }, 10000);
+        it('should emit offline if the robot never emits', async () => {
+            const service = new TelemetryService({ url: '', token: '' });
+            // Mock 5 heartbeat messages
+            jest.spyOn(service, 'subscribe').mockReturnValue(NEVER);
+            const lastValue = await lastValueFrom(service.getRobotStatusChanges('project', 'callsign', 100, 10).pipe(take(2)));
+            expect(lastValue).toEqual(CallsignStatus.OFFLINE);
+        });
+        it('should emit an error if the telemetry errors', async () => {
+            const service = new TelemetryService({ url: '', token: '' });
+            // Mock 5 heartbeat messages
+            jest.spyOn(service, 'subscribe').mockReturnValue(throwError(() => new Error('test')));
+            const lastValue = await lastValueFrom(service.getRobotStatusChanges('project', 'callsign', 100, 10).pipe(take(2)));
+            expect(lastValue).toEqual(CallsignStatus.ERROR);
+        });
+    });
+});

package/services/TelemetryServiceNode.js

@@ -1,11 +1,7 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TelemetryServiceNode = void 0;
-const TelemetryService_1 = require("./TelemetryService");
-const TelemetryStreamNode_1 = require("../api/streams/telemetry/TelemetryStreamNode");
-class TelemetryServiceNode extends TelemetryService_1.TelemetryService {
+import { TelemetryService } from './TelemetryService';
+import { TelemetryStreamNode } from '../api/streams/telemetry/TelemetryStreamNode';
+export class TelemetryServiceNode extends TelemetryService {
     getStream(config) {
-        return new TelemetryStreamNode_1.TelemetryStreamNode(config);
+        return new TelemetryStreamNode(config);
     }
 }
-exports.TelemetryServiceNode = TelemetryServiceNode;

package/services/TimeSyncerService.js

@@ -1,18 +1,15 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TimeSyncerService = void 0;
-const RocosError_1 = require("../models/RocosError");
-const api_1 = require("../constants/api");
-const BaseServiceAbstract_1 = require("./BaseServiceAbstract");
-const RocosLogger_1 = require("../logger/RocosLogger");
-const formatServiceUrl_1 = require("../helpers/formatServiceUrl");
-class TimeSyncerService extends BaseServiceAbstract_1.BaseServiceAbstract {
+import { RocosError, errorCodes } from '../models/RocosError';
+import { API_SERVER_TIME_URL } from '../constants/api';
+import { BaseServiceAbstract } from './BaseServiceAbstract';
+import { RocosLogger } from '../logger/RocosLogger';
+import { formatServiceUrl } from '../helpers/formatServiceUrl';
+export class TimeSyncerService extends BaseServiceAbstract {
     constructor(config) {
         super(config);
-        this.logger = RocosLogger_1.RocosLogger.getInstance(`TimeSyncerService(${this.config.url})`);
+        this.logger = RocosLogger.getInstance(`TimeSyncerService(${this.config.url})`);
     }
     getError(e) {
-        return new RocosError_1.RocosError(e, RocosError_1.errorCodes.TIME_SYNCER_SERVICE_ERROR);
+        return new RocosError(e, errorCodes.TIME_SYNCER_SERVICE_ERROR);
     }
     getStatus() {
         return true;
@@ -21,7 +18,6 @@ class TimeSyncerService extends BaseServiceAbstract_1.BaseServiceAbstract {
      * Get Server Time
      */
     getServerTime() {
-        return this.callGet(formatServiceUrl_1.formatServiceUrl(api_1.API_SERVER_TIME_URL, { url: this.config.url }, this.config.insecure), 'Failed to get server time.');
+        return this.callGet(formatServiceUrl(API_SERVER_TIME_URL, { url: this.config.url }, this.config.insecure), 'Failed to get server time.');
     }
 }
-exports.TimeSyncerService = TimeSyncerService;