@dronedeploy/rocos-js-sdk 4.4.4 → 4.4.6

package/esm/services/TelemetryService.js

@@ -1,5 +1,5 @@
 import { BehaviorSubject, catchError, combineLatest, defer, distinctUntilChanged, from, interval, map, mergeAll, of, startWith, } from 'rxjs';
-import { CallsignStatus, CallsignsLookup, CallsignsLookupType, RocosError, SubscriberStatusEnum, TelemetryMonitorStatus, errorCodes, } from '../models';
+import { CallsignStatus, CallsignsLookup, RocosError, SubscriberStatusEnum, TelemetryMonitorStatus, errorCodes, } from '../models';
 import { filter, finalize } from 'rxjs/operators';
 import { BaseStreamService } from './BaseStreamService';
 import { IDENTIFIER_NAME_TELEMETRY } from '../constants/identifier';
@@ -52,31 +52,42 @@ export class TelemetryService extends BaseStreamService {
         // 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(params.projectId, callsignsLookup, sources, scope),
-            callsigns: callsignsLookup?.lookupType === CallsignsLookupType.List ? callsignsLookup.lookupValue : [],
+            callsigns: callsignsLookup.getCallsigns(),
             sources,
         };
         // `defer` acquires the stream only when subscribed; `finalize` releases it on unsubscribe, error
-        // and complete — so acquire and release stay balanced on every path.
+        // and complete — so acquire and release stay balanced on every path. The registry refcount taken
+        // here keeps the stream alive until the finalize, so everything in between is race-free.
         return defer(() => {
-            let acquired;
-            const stream$ = this.createStream(params.projectId, callsignsLookup, sources, scope, (stream) => {
-                acquired = stream;
+            const { stream, isNew, ready, release } = this.acquireStream(IDENTIFIER_NAME_TELEMETRY, this.buildStreamConfig(params.projectId, callsignsLookup, sources, scope));
+            try {
                 stream.addSubscription(subscriptionParams);
-            }).then((stream) => {
-                if (!this.statusSubscription) {
-                    this.statusSubscription = stream.statusStream$.subscribe((msg) => {
-                        this.status = msg === SubscriberStatusEnum.STOPPED || msg === SubscriberStatusEnum.ALIVE;
-                        this.status$.next(msg);
+                // Forward the stream's status onto the per-scope subject once, at creation; it ends when the
+                // stream stops (statusStream$ completes), so it is not re-created or leaked across subscribers.
+                if (isNew) {
+                    stream.statusStream$.subscribe((msg) => {
+                        this.streamStatusSubject$.next({
+                            scope,
+                            status: msg,
+                        });
                     });
                 }
-                return from(stream.messageStream$);
-            });
-            return from(stream$).pipe(mergeAll(), filter((message) => {
-                return callsigns.includes(message.callsign) && sources.includes(message.source);
-            }), finalize(() => acquired?.removeSubscription(subscriptionParams, params.terminateReceiverGroupOnUnsubscribe)));
+            }
+            catch (e) {
+                // finalize below is not wired up yet, so a throw here must hand the refcount back itself.
+                release();
+                throw e;
+            }
+            // status$ / getStatus() are driven by the acquireStream factory (BaseStreamService), not here.
+            const messages$ = ready.then(() => from(stream.messageStream$));
+            return from(messages$).pipe(mergeAll(), filter((message) => {
+                return callsignsLookup.includesCallsign(message.callsign) && sources.includes(message.source);
+            }), finalize(() => {
+                void stream.removeSubscription(subscriptionParams, params.terminateReceiverGroupOnUnsubscribe);
+                release();
+            }));
         });
     }
     /**
@@ -156,8 +167,8 @@ export class TelemetryService extends BaseStreamService {
             return `${params.projectId}-default-${flattenCallsignsLookup(callsignsLookup).join()}`;
         return `${params.projectId}-default`;
     }
-    async createStream(projectId, callsignsLookup, sources, scope, onAcquire) {
-        const newStream = await this.createStreamFromConfig(IDENTIFIER_NAME_TELEMETRY, {
+    buildStreamConfig(projectId, callsignsLookup, sources, scope) {
+        return {
             url: this.config.url,
             projectId,
             callsignsLookup,
@@ -169,16 +180,7 @@ export class TelemetryService extends BaseStreamService {
             insecure: this.config.insecure,
             transport: this.config.transport,
             fetch: this.config.fetch,
-        }, onAcquire);
-        if (!newStream.isNew) {
-            newStream.stream.statusStream$.subscribe((msg) => {
-                this.streamStatusSubject$.next({
-                    scope,
-                    status: msg,
-                });
-            });
-        }
-        return newStream.stream;
+        };
     }
     getStream(config) {
         if (config.transport === 'grpc-web') {

package/esm/services/WebRTCSignallingService.js

@@ -1,4 +1,4 @@
-import { IDENTIFIER_NAME_COMMAND } from '../constants/identifier';
+import { IDENTIFIER_NAME_WEBRTC_SIGNALLING } from '../constants/identifier';
 import { RocosLogger } from '../logger/RocosLogger';
 import { RocosStore } from '../store/RocosStore';
 import { StreamRegister } from '../api/StreamRegister';
@@ -34,11 +34,9 @@ export class WebRTCSignallingService {
     }
     async createSignallingStream() {
         const scope = 'default';
-        const identifier = StreamRegister.getIdentifier(IDENTIFIER_NAME_COMMAND, scope);
-        const streamRegister = StreamRegister.getInstance();
-        let stream = streamRegister.getStream(identifier);
-        if (!stream) {
-            stream = this.getStream({
+        const identifier = StreamRegister.getIdentifier(IDENTIFIER_NAME_WEBRTC_SIGNALLING, scope);
+        const { stream, ready } = StreamRegister.getInstance().acquireStream(identifier, () => {
+            const newStream = this.getStream({
                 url: this.config.url,
                 token: this.config.token,
                 scope,
@@ -46,13 +44,13 @@ export class WebRTCSignallingService {
                 port: this.config.port,
                 insecure: this.config.insecure,
             });
-            stream.statusStream$.subscribe((msg) => {
+            newStream.statusStream$.subscribe((msg) => {
                 this.status = msg === SubscriberStatusEnum.STOPPED || msg === SubscriberStatusEnum.ALIVE;
                 this.status$.next(msg);
             });
-            streamRegister.addStream(stream);
-            await this.initStream(stream);
-        }
+            return newStream;
+        }, (newStream) => this.initStream(newStream));
+        await ready;
         return stream;
     }
     async initStream(stream) {

package/esm/services/robot-status/connectivity.d.ts

@@ -36,18 +36,19 @@ export declare const buildConnectionsUrl: (serviceId: string, baseUrl: string, p
 export declare const mapConnectionStatus: (connection?: IConnectedCallsign | null) => ServiceConnection;
 /**
  * Aggregates per-service connection states into an overall verdict:
- * - `ONLINE`   — at least one service connected and none disconnected.
- * - `DEGRADED` — a genuine mix: some connected, some disconnected.
+ * - `DEGRADED` — any service reports an explicit `FAILED` fault, or a genuine mix (some connected,
+ *                some disconnected).
+ * - `ONLINE`   — at least one service connected and none disconnected or failed.
  * - `OFFLINE`  — nothing connected.
  *
- * `UNKNOWN` services (e.g. not yet polled) never force `DEGRADED`, so startup
- * settles on `OFFLINE` (gray) rather than a spurious flashing-red degraded state.
+ * A `FAILED` service forces `DEGRADED` even when nothing else is connected, so a fault (e.g. a failed
+ * deployment) raises attention rather than reading as a plain, switched-off `OFFLINE`.
  *
- * Note: this optimism also means a service held `UNKNOWN` indefinitely (e.g. an
- * endpoint whose polls keep failing) does not by itself pull the aggregate below
- * `ONLINE` — a deliberate v1 tradeoff to keep transient errors from flapping the
- * indicator. Surfacing a long-lived failure distinctly (likely via health rather
- * than connectivity) is left as a future refinement.
+ * `UNKNOWN` services (e.g. not yet polled) never force `DEGRADED`, so startup settles on `OFFLINE`
+ * (gray) rather than a spurious flashing-red degraded state. This optimism also means a service held
+ * `UNKNOWN` indefinitely (e.g. an endpoint whose polls keep failing) does not by itself pull the
+ * aggregate below `ONLINE` — a deliberate tradeoff to keep transient errors from flapping the
+ * indicator; a service that wants to be surfaced reports `FAILED` explicitly.
  */
 export declare const aggregateConnectivity: (services: Record<string, ServiceConnection>) => RobotConnectivity;
 /**
@@ -66,11 +67,14 @@ export interface ConnectivityDeps {
     insecure?: boolean;
     /** The telemetry-liveness signal (from `getTelemetryLiveness`), folded in as one service. */
     telemetryLiveness$: Observable<ServiceConnection>;
+    /** Caller-injected connectivity signals, keyed by service id, folded in on equal footing. */
+    extraServices?: Record<string, Observable<ServiceConnection>>;
 }
 /**
  * Emits the robot's {@link RobotConnectivityStatus} — the per-service breakdown
- * plus the aggregate verdict — for the configured `expectedServices`. HTTP
- * services are polled; `telemetry-liveness` uses the supplied observable; any
- * unrecognised service id resolves to `UNKNOWN`.
+ * plus the aggregate verdict — for the configured `expectedServices`, plus any
+ * caller-injected `extraServices` (folded in on equal footing). HTTP services
+ * are polled; `telemetry-liveness` and injected services use their supplied
+ * observable; any unrecognised service id resolves to `UNKNOWN`.
  */
 export declare const getConnectivityChanges: (deps: ConnectivityDeps, projectId: string, callsign: string, expectedServices?: string[], pollMs?: number) => Observable<RobotConnectivityStatus>;

package/esm/services/robot-status/connectivity.js

@@ -52,21 +52,24 @@ export const mapConnectionStatus = (connection) => {
 };
 /**
  * Aggregates per-service connection states into an overall verdict:
- * - `ONLINE`   — at least one service connected and none disconnected.
- * - `DEGRADED` — a genuine mix: some connected, some disconnected.
+ * - `DEGRADED` — any service reports an explicit `FAILED` fault, or a genuine mix (some connected,
+ *                some disconnected).
+ * - `ONLINE`   — at least one service connected and none disconnected or failed.
  * - `OFFLINE`  — nothing connected.
  *
- * `UNKNOWN` services (e.g. not yet polled) never force `DEGRADED`, so startup
- * settles on `OFFLINE` (gray) rather than a spurious flashing-red degraded state.
+ * A `FAILED` service forces `DEGRADED` even when nothing else is connected, so a fault (e.g. a failed
+ * deployment) raises attention rather than reading as a plain, switched-off `OFFLINE`.
  *
- * Note: this optimism also means a service held `UNKNOWN` indefinitely (e.g. an
- * endpoint whose polls keep failing) does not by itself pull the aggregate below
- * `ONLINE` — a deliberate v1 tradeoff to keep transient errors from flapping the
- * indicator. Surfacing a long-lived failure distinctly (likely via health rather
- * than connectivity) is left as a future refinement.
+ * `UNKNOWN` services (e.g. not yet polled) never force `DEGRADED`, so startup settles on `OFFLINE`
+ * (gray) rather than a spurious flashing-red degraded state. This optimism also means a service held
+ * `UNKNOWN` indefinitely (e.g. an endpoint whose polls keep failing) does not by itself pull the
+ * aggregate below `ONLINE` — a deliberate tradeoff to keep transient errors from flapping the
+ * indicator; a service that wants to be surfaced reports `FAILED` explicitly.
  */
 export const aggregateConnectivity = (services) => {
     const values = Object.values(services);
+    if (values.includes(ServiceConnection.FAILED))
+        return RobotConnectivity.DEGRADED;
     const hasConnected = values.includes(ServiceConnection.CONNECTED);
     const hasDisconnected = values.includes(ServiceConnection.DISCONNECTED);
     if (hasConnected && hasDisconnected)
@@ -99,24 +102,32 @@ const connectivityEquals = (a, b) => {
 };
 /**
  * Emits the robot's {@link RobotConnectivityStatus} — the per-service breakdown
- * plus the aggregate verdict — for the configured `expectedServices`. HTTP
- * services are polled; `telemetry-liveness` uses the supplied observable; any
- * unrecognised service id resolves to `UNKNOWN`.
+ * plus the aggregate verdict — for the configured `expectedServices`, plus any
+ * caller-injected `extraServices` (folded in on equal footing). HTTP services
+ * are polled; `telemetry-liveness` and injected services use their supplied
+ * observable; any unrecognised service id resolves to `UNKNOWN`.
  */
 export const getConnectivityChanges = (deps, projectId, callsign, expectedServices = DEFAULT_EXPECTED_SERVICES, pollMs = DEFAULT_CONNECTIVITY_POLL_MS) => {
+    const extraServices = deps.extraServices ?? {};
+    const serviceIds = [...expectedServices, ...Object.keys(extraServices).filter((id) => !expectedServices.includes(id))];
     // combineLatest([]) completes without emitting; emit an explicit empty/offline status instead.
-    if (expectedServices.length === 0) {
+    if (serviceIds.length === 0) {
         return of({ overall: RobotConnectivity.OFFLINE, services: {} });
     }
-    const perService = expectedServices.map((serviceId) => {
+    const perService = serviceIds.map((serviceId) => {
         let source$;
         if (serviceId === TELEMETRY_LIVENESS_SERVICE) {
             source$ = deps.telemetryLiveness$;
         }
-        else if (serviceId in CONNECTION_SERVICE_PREFIXES) {
+        else if (Object.prototype.hasOwnProperty.call(CONNECTION_SERVICE_PREFIXES, serviceId)) {
             const url = buildConnectionsUrl(serviceId, deps.baseUrl, projectId, callsign, deps.insecure);
             source$ = getServiceConnectionChanges(deps.httpGet, url, pollMs);
         }
+        else if (Object.prototype.hasOwnProperty.call(extraServices, serviceId)) {
+            // Contain an injected observable's errors as UNKNOWN, mirroring the built-in sources, so a
+            // faulty caller signal can't error out combineLatest and tear down the whole aggregate.
+            source$ = extraServices[serviceId].pipe(catchError(() => of(ServiceConnection.UNKNOWN)));
+        }
         else {
             source$ = of(ServiceConnection.UNKNOWN);
         }

package/esm/services/robot-status/reportedStatus.d.ts

@@ -1,10 +1,12 @@
 import { Observable } from 'rxjs';
-import { RobotHealth, RobotReadiness, ServiceConnection } from '../../models';
+import { RobotHealth, RobotReadiness, RobotStatusContributors, ServiceConnection } from '../../models';
 import { TelemetryService } from '../TelemetryService';
 /** The new agent topic carrying health + readiness (replaces the heartbeat). */
 export declare const ROBOT_STATUS_SOURCE = "/diagnostics/robot/status";
 /** The legacy heartbeat topic — liveness only, no status payload. */
 export declare const LEGACY_HEARTBEAT_SOURCE = "/rocos/agent/telemetry/heartbeat";
+/** The per-contributor breakdown behind the reported status (health + readiness). */
+export declare const ROBOT_STATUS_CONTRIBUTORS_SOURCE = "/diagnostics/robot/status/contributors";
 export interface ReportedRobotStatus {
     health: RobotHealth;
     readiness: RobotReadiness;
@@ -28,6 +30,17 @@ export declare const parseRobotReadiness: (value: unknown) => RobotReadiness;
  * new topic.
  */
 export declare const getReportedStatusChanges: (telemetry: TelemetryService, projectId: string, callsign: string) => Observable<ReportedRobotStatus>;
+/**
+ * Emits the per-contributor breakdown behind the robot's reported health and
+ * readiness, from the agent's `robot/status/contributors` topic. Each
+ * contributor's integer wire value is mapped onto {@link RobotHealth} /
+ * {@link RobotReadiness}; a missing `health`/`readiness` array becomes `[]`.
+ *
+ * Starts with an empty breakdown so consumers combining this with other streams
+ * emit immediately, and — like {@link getReportedStatusChanges} — a telemetry
+ * error falls back to an empty breakdown rather than terminating the stream.
+ */
+export declare const getStatusContributorsChanges: (telemetry: TelemetryService, projectId: string, callsign: string) => Observable<RobotStatusContributors>;
 /**
  * Emits the `telemetry-liveness` connectivity signal: whether a heartbeat (from
  * either the new `robot/status` topic or the legacy heartbeat) has been received

package/esm/services/robot-status/reportedStatus.js

@@ -1,9 +1,11 @@
 import { catchError, combineLatest, distinctUntilChanged, filter, interval, map, merge, of, scan, startWith, } from 'rxjs';
-import { RobotHealth, RobotReadiness, ServiceConnection } from '../../models';
+import { RobotHealth, RobotReadiness, ServiceConnection, } from '../../models';
 /** The new agent topic carrying health + readiness (replaces the heartbeat). */
 export const ROBOT_STATUS_SOURCE = '/diagnostics/robot/status';
 /** The legacy heartbeat topic — liveness only, no status payload. */
 export const LEGACY_HEARTBEAT_SOURCE = '/rocos/agent/telemetry/heartbeat';
+/** The per-contributor breakdown behind the reported status (health + readiness). */
+export const ROBOT_STATUS_CONTRIBUTORS_SOURCE = `${ROBOT_STATUS_SOURCE}/contributors`;
 const DEFAULT_HEARTBEAT_TIMEOUT_MS = 5000;
 const DEFAULT_INTERVAL_MS = 2000;
 /**
@@ -78,6 +80,38 @@ export const getReportedStatusChanges = (telemetry, projectId, callsign) => {
     // UNKNOWN/UNKNOWN (matching getTelemetryLiveness) so subscribers get an honest value.
     catchError(() => of({ health: RobotHealth.UNKNOWN, readiness: RobotReadiness.UNKNOWN })));
 };
+const toContributor = (raw, parse) => ({
+    id: raw.id ?? '',
+    component: raw.component ?? '',
+    reason: raw.reason ?? '',
+    status: parse(raw.value),
+});
+const EMPTY_CONTRIBUTORS = { health: [], readiness: [] };
+/**
+ * Emits the per-contributor breakdown behind the robot's reported health and
+ * readiness, from the agent's `robot/status/contributors` topic. Each
+ * contributor's integer wire value is mapped onto {@link RobotHealth} /
+ * {@link RobotReadiness}; a missing `health`/`readiness` array becomes `[]`.
+ *
+ * Starts with an empty breakdown so consumers combining this with other streams
+ * emit immediately, and — like {@link getReportedStatusChanges} — a telemetry
+ * error falls back to an empty breakdown rather than terminating the stream.
+ */
+export const getStatusContributorsChanges = (telemetry, projectId, callsign) => {
+    return telemetry
+        .subscribe({
+        projectId,
+        callsigns: [callsign],
+        sources: [ROBOT_STATUS_CONTRIBUTORS_SOURCE],
+    })
+        .pipe(map((message) => {
+        const payload = message.payload ?? {};
+        return {
+            health: (payload.health ?? []).map((c) => toContributor(c, parseRobotHealth)),
+            readiness: (payload.readiness ?? []).map((c) => toContributor(c, parseRobotReadiness)),
+        };
+    }), startWith(EMPTY_CONTRIBUTORS), distinctUntilChanged((a, b) => JSON.stringify(a) === JSON.stringify(b)), catchError(() => of(EMPTY_CONTRIBUTORS)));
+};
 /**
  * Emits the `telemetry-liveness` connectivity signal: whether a heartbeat (from
  * either the new `robot/status` topic or the legacy heartbeat) has been received

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dronedeploy/rocos-js-sdk",
-  "version": "4.4.4",
+  "version": "4.4.6",
   "description": "Javascript SDK for rocos",
   "main": "cjs/index.js",
   "module": "esm/index.js",
@@ -42,5 +42,10 @@
     }
   },
   "repository": {},
-  "private": false
+  "private": false,
+  "overrides": {
+    "openapi-typescript": {
+      "typescript": "$typescript"
+    }
+  }
 }