@dronedeploy/rocos-js-sdk 0.0.1 → 3.0.0-alpha.6

package/api/atoms/StreamHeartbeat.d.ts

@@ -0,0 +1,27 @@
+export declare class StreamHeartbeat {
+    private identifier;
+    private callback?;
+    private timeout?;
+    private beats;
+    private interval?;
+    private healthInterval?;
+    private healthLastSeenDate;
+    private healthMisses;
+    private healthTimeout;
+    private healthMaxTimeout;
+    private healthMaxMisses;
+    private healthCheckStatusCallback?;
+    private healthCheckErrorCallback?;
+    private logger;
+    constructor(identifier: string);
+    setHealthTimeout(healthTimeout: number): StreamHeartbeat;
+    setHealthMaxTimeout(healthMaxTimeout: number): StreamHeartbeat;
+    setHealthMaxMisses(healthMaxMisses: number): StreamHeartbeat;
+    setHealthCheckStatusCallback(healthCheckStatusCallback: (status: boolean) => Promise<void>): StreamHeartbeat;
+    setHealthCheckErrorCallback(healthCheckErrorCallback: () => Promise<void>): StreamHeartbeat;
+    start(callback: () => void, timeout: number): void;
+    stop(): void;
+    pump(): number;
+    private checkHealth;
+    stopHealthCheck(): void;
+}

package/api/atoms/StreamHeartbeat.js

@@ -0,0 +1,111 @@
+import { RocosLogger } from '../../logger/RocosLogger';
+export class StreamHeartbeat {
+    constructor(identifier) {
+        this.beats = 0;
+        this.healthLastSeenDate = new Date();
+        this.healthMisses = 0;
+        this.healthTimeout = 6000; // check for healthy heartbeat every 6 seconds
+        this.healthMaxTimeout = 10;
+        this.healthMaxMisses = 5;
+        this.identifier = identifier;
+        this.logger = RocosLogger.getInstance(`StreamHeartbeat(${this.identifier})`);
+    }
+    setHealthTimeout(healthTimeout) {
+        this.healthTimeout = healthTimeout;
+        return this;
+    }
+    setHealthMaxTimeout(healthMaxTimeout) {
+        this.healthMaxTimeout = healthMaxTimeout;
+        return this;
+    }
+    setHealthMaxMisses(healthMaxMisses) {
+        this.healthMaxMisses = healthMaxMisses;
+        return this;
+    }
+    setHealthCheckStatusCallback(healthCheckStatusCallback) {
+        this.healthCheckStatusCallback = healthCheckStatusCallback;
+        return this;
+    }
+    setHealthCheckErrorCallback(healthCheckErrorCallback) {
+        this.healthCheckErrorCallback = healthCheckErrorCallback;
+        return this;
+    }
+    start(callback, timeout) {
+        if (!this.interval) {
+            this.callback = callback;
+            this.timeout = timeout;
+            this.logger.info('Creating stream heartbeat');
+            this.interval = setInterval(this.callback, this.timeout);
+        }
+        else {
+            this.logger.warn('Stream heartbeat already exists');
+        }
+    }
+    stop() {
+        try {
+            this.logger.info('Removing stream heartbeat timer');
+            clearInterval(this.interval);
+            this.interval = undefined;
+        }
+        catch (e) {
+            this.logger.error(`Error killing stream heartbeat timer ${e}`);
+        }
+    }
+    pump() {
+        // if the health check has not started yet, we initialise it
+        if (!this.healthInterval) {
+            this.logger.debug('Starting health check timer');
+            this.healthInterval = setInterval(this.checkHealth, this.healthTimeout);
+            this.healthLastSeenDate = new Date();
+            this.healthMisses = 0;
+        }
+        else {
+            this.logger.debug(`Updating health check timer: ${this.healthLastSeenDate}, ${this.healthMisses}`);
+            this.healthLastSeenDate = new Date();
+            this.healthMisses = 0;
+        }
+        return this.beats++;
+    }
+    async checkHealth() {
+        this.logger.debug('Checking health');
+        let status = true;
+        // check to see if we have received a heartbeat in in the last few seconds
+        const lastSeenInSeconds = (new Date().getTime() - this.healthLastSeenDate.getTime()) / 1000;
+        if (lastSeenInSeconds > this.healthMaxTimeout && this.healthMaxMisses) {
+            status = false;
+            this.healthMisses += 1;
+            this.logger.warn(`Heartbeat is more than ${this.healthMaxTimeout} seconds, delay: ${lastSeenInSeconds} seconds, misses: ${this.healthMisses}`);
+            if (this.healthMisses === this.healthMaxMisses) {
+                this.stopHealthCheck();
+                this.logger.error(`Stopping Heartbeat as it is more than ${this.healthMaxTimeout} seconds, delay - ${lastSeenInSeconds} seconds, misses: ${this.healthMisses}`);
+                if (this.healthCheckErrorCallback) {
+                    await this.healthCheckErrorCallback();
+                }
+            }
+        }
+        else if (lastSeenInSeconds > this.healthMaxTimeout) {
+            status = false;
+            this.logger.warn(`Stopping Heartbeat as it is more than ${this.healthMaxTimeout} seconds, delay - ${lastSeenInSeconds} seconds`);
+            this.stopHealthCheck();
+            if (this.healthCheckErrorCallback) {
+                await this.healthCheckErrorCallback();
+            }
+        }
+        if (this.healthCheckStatusCallback) {
+            await this.healthCheckStatusCallback(status);
+        }
+    }
+    stopHealthCheck() {
+        if (this.healthInterval) {
+            try {
+                this.logger.info('Stopping timer');
+                clearInterval(this.healthInterval);
+                this.healthInterval = undefined;
+                this.logger.info('Removed timer');
+            }
+            catch (e) {
+                this.logger.error('error removing timer', e);
+            }
+        }
+    }
+}

package/api/streams/caller/CallerStream.d.ts

@@ -0,0 +1,13 @@
+import { ICallerParams, IRocosCallerMessage, IStreamConfig } from '../../../models';
+import { Observable } from 'rxjs';
+import { RequestCancellation, ServiceRequest } from '../../../grpc/serviette.v1_pb';
+import { CallerStreamAbstract } from './CallerStreamAbstract';
+export declare class CallerStream extends CallerStreamAbstract {
+    private client;
+    constructor(config: IStreamConfig);
+    protected callService(request: ServiceRequest, params: ICallerParams): Observable<IRocosCallerMessage>;
+    protected cancelService(request: RequestCancellation, params: ICallerParams): Observable<IRocosCallerMessage>;
+    private handleStream;
+    protected getPayload(payload: string): Uint8Array;
+    private getMetadata;
+}

package/api/streams/caller/CallerStream.js

@@ -0,0 +1,77 @@
+import { RocosCallerMessage, SubscriberStatusEnum, } from '../../../models';
+import { Observable } from 'rxjs';
+import { CallerStreamAbstract } from './CallerStreamAbstract';
+import { GrpcWebFetchTransport } from '@protobuf-ts/grpcweb-transport';
+import { RocosLogger } from '../../../logger/RocosLogger';
+import { WebServiceCallerClient } from '../../../grpc/serviette.v1_pb.client';
+import { stringToUint8Array } from '../../../helpers/stringToUint8Array';
+export class CallerStream extends CallerStreamAbstract {
+    constructor(config) {
+        super(config);
+        this.logger = RocosLogger.getInstance(`CallerStream(${this.identifier})`);
+        const protocol = config.insecure ? 'http' : 'https';
+        const transport = new GrpcWebFetchTransport({
+            baseUrl: `${protocol}://${this.url}`,
+        });
+        this.client = new WebServiceCallerClient(transport);
+    }
+    callService(request, params) {
+        const meta = this.getMetadata(params.projectId, params.callsign, params.subSystem);
+        const stream = this.client.callService(request, { meta });
+        return this.handleStream(stream, params, 'invoke');
+    }
+    cancelService(request, params) {
+        const meta = this.getMetadata(params.projectId, params.callsign, params.subSystem);
+        const stream = this.client.cancelService(request, { meta });
+        return this.handleStream(stream, params, 'cancel');
+    }
+    handleStream(stream, params, requestType) {
+        return new Observable((emitter) => {
+            this.subscriberStatus = SubscriberStatusEnum.ALIVE;
+            this.statusStream$.next(this.subscriberStatus);
+            stream.responses.onMessage((message) => {
+                const msg = RocosCallerMessage.fromModel(message);
+                emitter.next(msg);
+                this.logger.debug(`${requestType}Request - on(data)`, {
+                    message,
+                    projectId: params.projectId,
+                    callsign: params.callsign,
+                    component: params.component,
+                    topic: params.topic,
+                });
+            });
+            stream.responses.onError((error) => {
+                this.logger.debug(`${requestType}Request - on(error)`, {
+                    error,
+                    projectId: params.projectId,
+                    callsign: params.callsign,
+                    component: params.component,
+                    topic: params.topic,
+                });
+                emitter.error(error);
+            });
+            stream.responses.onComplete(() => {
+                this.subscriberStatus = SubscriberStatusEnum.STOPPED;
+                this.statusStream$.next(this.subscriberStatus);
+                this.logger.debug(`${requestType}Request - on(end)`, {
+                    projectId: params.projectId,
+                    callsign: params.callsign,
+                    component: params.component,
+                    topic: params.topic,
+                });
+                emitter.complete();
+            });
+        });
+    }
+    getPayload(payload) {
+        return stringToUint8Array(payload);
+    }
+    getMetadata(projectId, callsign, subsystem) {
+        return {
+            'authorization': this.token,
+            'r-p': projectId,
+            'r-cs': callsign,
+            'r-s': subsystem ?? '',
+        };
+    }
+}

package/api/streams/caller/CallerStreamAbstract.d.ts

@@ -0,0 +1,23 @@
+import { BehaviorSubject, Observable } from 'rxjs';
+import { ICallerInvokeParams, ICallerParams, ICallerStream, IRocosCallerMessage, IStreamConfig, SubscriberStatusEnum } from '../../../models';
+import { RequestCancellation } from '../../../grpc/serviette.v1_pb';
+import { Logger } from 'loglevel';
+export declare abstract class CallerStreamAbstract implements ICallerStream {
+    identifier: string;
+    statusStream$: BehaviorSubject<SubscriberStatusEnum>;
+    protected token: string;
+    private scope;
+    protected url: string;
+    protected subscriberStatus: SubscriberStatusEnum;
+    protected logger: Logger;
+    protected constructor(config: IStreamConfig);
+    protected abstract cancelService(request: RequestCancellation, params: ICallerParams): Observable<IRocosCallerMessage>;
+    protected abstract callService(request: RequestCancellation, params: ICallerParams): Observable<IRocosCallerMessage>;
+    protected abstract getPayload(payload: string): Uint8Array;
+    setToken(token: string): void;
+    stopStream(): void;
+    invokeRequest(params: ICallerInvokeParams): Observable<IRocosCallerMessage>;
+    cancelRequest(params: ICallerParams): Observable<IRocosCallerMessage>;
+    private createCancellationRequest;
+    private createServiceRequest;
+}

package/api/streams/caller/CallerStreamAbstract.js

@@ -0,0 +1,87 @@
+import { BehaviorSubject } from 'rxjs';
+import { SubscriberStatusEnum, } from '../../../models';
+import { RequestCancellation, ServiceRequest, UIDVersion } from '../../../grpc/serviette.v1_pb';
+import { RocosURI, RocosURIQueryValues, RocosURIScheme } from '../../../grpc/serviette.uri.v1_pb';
+import { IDENTIFIER_NAME_CALLER } from '../../../constants/identifier';
+import { RocosStore } from '../../../store/RocosStore';
+import { StreamRegister } from '../../StreamRegister';
+import { filter } from 'rxjs/operators';
+import { v4 as uuidv4 } from 'uuid';
+export class CallerStreamAbstract {
+    constructor(config) {
+        this.subscriberStatus = SubscriberStatusEnum.STOPPED;
+        this.scope = config.scope;
+        this.identifier = StreamRegister.getIdentifier(IDENTIFIER_NAME_CALLER, this.scope);
+        this.token = config.token;
+        this.url = config.url;
+        this.statusStream$ = new BehaviorSubject(SubscriberStatusEnum.STOPPED);
+        RocosStore.getChangeSubject()
+            .pipe(filter((message) => {
+            return message.type === 'token' && message.url === this.url;
+        }))
+            .subscribe((msg) => {
+            this.token = msg.data;
+        });
+    }
+    setToken(token) {
+        this.token = token;
+    }
+    stopStream() {
+        // do nothing for now
+    }
+    invokeRequest(params) {
+        this.logger.info('invokeRequest', params);
+        const responseLevel = params.responseLevelNumber;
+        const request = this.createServiceRequest(params.projectId, params.callsign, params.component, params.topic, responseLevel, params.payload, params.uid, params.query);
+        return this.callService(request, params);
+    }
+    cancelRequest(params) {
+        this.logger.info('cancelRequest', params);
+        const request = this.createCancellationRequest(params.uid);
+        return this.cancelService(request, params);
+    }
+    createCancellationRequest(uid) {
+        return RequestCancellation.create({
+            uid: {
+                content: {
+                    oneofKind: 'hash',
+                    hash: uid,
+                },
+            },
+        });
+    }
+    createServiceRequest(projectId, callsign, component, topic, responseLevel, payload, uid, query) {
+        const uri = RocosURI.create({
+            path: {
+                project: projectId,
+                callsign,
+                component,
+                topic,
+            },
+            scheme: RocosURIScheme.GRPC,
+        });
+        if (query) {
+            const queryMap = uri.query;
+            Object.keys(query).forEach((key) => {
+                queryMap[key] = RocosURIQueryValues.create({
+                    values: [...query[key]],
+                });
+            });
+        }
+        return ServiceRequest.create({
+            header: {
+                created: Date.now().toString(),
+                source: uri,
+                responseLevel,
+            },
+            uid: {
+                version: UIDVersion.HEADER_HASH_RAND,
+                content: {
+                    oneofKind: 'hash',
+                    hash: uid ?? uuidv4(),
+                },
+            },
+            payload: this.getPayload(payload),
+        });
+    }
+}

package/api/streams/caller/CallerStreamNode.d.ts

@@ -0,0 +1,13 @@
+import { ICallerParams, IRocosCallerMessage, IStreamConfig } from '../../../models';
+import { Observable } from 'rxjs';
+import { RequestCancellation, ServiceRequest } from '../../../grpc/serviette.v1_pb';
+import { CallerStreamAbstract } from './CallerStreamAbstract';
+export declare class CallerStreamNode extends CallerStreamAbstract {
+    private client;
+    constructor(config: IStreamConfig);
+    protected cancelService(request: RequestCancellation, params: ICallerParams): Observable<IRocosCallerMessage>;
+    protected callService(request: ServiceRequest, params: ICallerParams): Observable<IRocosCallerMessage>;
+    private callStream;
+    protected getPayload(payload: string): Uint8Array;
+    private getMetadata;
+}

package/api/streams/caller/CallerStreamNode.js

@@ -0,0 +1,115 @@
+import * as grpc from '@grpc/grpc-js';
+import { RocosCallerMessage, SubscriberStatusEnum, } from '../../../models';
+import { Observable } from 'rxjs';
+import { RequestChannelMessage, } from '../../../grpc/serviette.v1_pb';
+import { CallerStreamAbstract } from './CallerStreamAbstract';
+import { RocosLogger } from '../../../logger/RocosLogger';
+import { ServiceCallerClient } from '../../../grpc/serviette.v1_pb.grpc-client';
+export class CallerStreamNode extends CallerStreamAbstract {
+    constructor(config) {
+        super(config);
+        this.logger = RocosLogger.getInstance(`CallerStreamNode(${this.identifier})`);
+        const port = config.port ?? 443;
+        const credentials = config.insecure ? grpc.credentials.createInsecure() : grpc.credentials.createSsl();
+        this.client = new ServiceCallerClient(`${this.url}:${port}`, credentials);
+    }
+    cancelService(request, params) {
+        return this.callStream(RequestChannelMessage.create({
+            content: {
+                oneofKind: 'cancellations',
+                cancellations: {
+                    cancellations: [request],
+                },
+            },
+        }), params, 'cancel');
+    }
+    callService(request, params) {
+        return this.callStream(RequestChannelMessage.create({
+            content: {
+                oneofKind: 'requests',
+                requests: {
+                    requests: [request],
+                },
+            },
+        }), params, 'invoke');
+    }
+    callStream(request, params, requestType) {
+        const metadata = this.getMetadata(params.projectId, params.callsign, params.subSystem);
+        let call;
+        return new Observable((emitter) => {
+            call = this.client.callServices(metadata);
+            this.logger.info(`${requestType}Request - call`);
+            this.subscriberStatus = SubscriberStatusEnum.ALIVE;
+            this.statusStream$.next(this.subscriberStatus);
+            call.write(request, () => {
+                if (this.logger.getLevel().valueOf() <= 2) {
+                    this.logger.info(`${requestType}Request write completed for - ${JSON.stringify(request, (_, v) => {
+                        return typeof v === 'bigint' ? `${v.toString()}n` : v;
+                    })}`);
+                }
+            });
+            call.on('data', (update) => {
+                const message = RocosCallerMessage.fromModel(update);
+                emitter.next(message);
+                this.logger.debug(`${requestType}Request - on(data)`, {
+                    message,
+                    projectId: params.projectId,
+                    callsign: params.callsign,
+                    component: params.component,
+                    topic: params.topic,
+                });
+            });
+            call.on('finish', () => {
+                this.logger.info(`${requestType}Request - on(finish) all writes are now complete`);
+                call.end();
+            });
+            call.on('end', () => {
+                this.subscriberStatus = SubscriberStatusEnum.STOPPED;
+                this.statusStream$.next(this.subscriberStatus);
+                this.logger.debug(`${requestType}Request - on(end)`, {
+                    projectId: params.projectId,
+                    callsign: params.callsign,
+                    component: params.component,
+                    topic: params.topic,
+                });
+                call.pause();
+                call.destroy();
+                this.client.close();
+                emitter.complete();
+            });
+            call.on('close', () => {
+                this.subscriberStatus = SubscriberStatusEnum.STOPPED;
+                this.statusStream$.next(this.subscriberStatus);
+                this.logger.debug(`${requestType}Request - on(close)`);
+            });
+            call.on('error', (error) => {
+                this.subscriberStatus = SubscriberStatusEnum.ERROR;
+                this.statusStream$.next(this.subscriberStatus);
+                if (/10 ABORTED: heartbeat watchdog strike/.exec(error.stack)) {
+                    this.logger.debug(`${requestType}Request grpc Error heartbeat error`, error);
+                    call.end();
+                    emitter.complete();
+                }
+                else {
+                    this.logger.error(`${requestType}Request - on(error)`, error);
+                    emitter.error(error);
+                }
+            });
+            return () => {
+                this.logger.debug('unsubscribing callStream');
+                call.cancel();
+            };
+        });
+    }
+    getPayload(payload) {
+        return Buffer.from(payload);
+    }
+    getMetadata(projectId, callsign, subsystem) {
+        const meta = new grpc.Metadata();
+        meta.add('r-p', projectId);
+        meta.add('r-cs', callsign);
+        meta.add('r-s', subsystem ?? '');
+        meta.add('authorization', this.token);
+        return meta;
+    }
+}

package/api/streams/command/CommandStream.d.ts

@@ -0,0 +1,10 @@
+import { ICommandParams, IRocosCommandMessage, IStreamConfig } from '../../../models';
+import { Observable } from 'rxjs';
+import { CommandRequest } from '../../../grpc/rambo.v1_pb';
+import { CommandStreamAbstract } from './CommandStreamAbstract';
+export declare class CommandStream extends CommandStreamAbstract {
+    private client;
+    constructor(config: IStreamConfig);
+    protected callStream(request: CommandRequest, params: ICommandParams): Observable<IRocosCommandMessage>;
+    private getMetadata;
+}

package/api/streams/command/CommandStream.js

@@ -0,0 +1,66 @@
+import { RocosCommandMessage, SubscriberStatusEnum, } from '../../../models';
+import { Observable } from 'rxjs';
+import { CommandClient } from '../../../grpc/rambo.v1_pb.client';
+import { CommandStreamAbstract } from './CommandStreamAbstract';
+import { GrpcWebFetchTransport } from '@protobuf-ts/grpcweb-transport';
+import { RocosLogger } from '../../../logger/RocosLogger';
+export class CommandStream extends CommandStreamAbstract {
+    constructor(config) {
+        super(config);
+        this.logger = RocosLogger.getInstance(`CommandStream(${this.identifier})`);
+        const protocol = config.insecure ? 'http' : 'https';
+        const transport = new GrpcWebFetchTransport({
+            baseUrl: `${protocol}://${this.url}`,
+        });
+        this.client = new CommandClient(transport);
+    }
+    callStream(request, params) {
+        const metadata = this.getMetadata(params.projectId, params.callsign);
+        const abortController = new AbortController();
+        return new Observable((emitter) => {
+            const call = this.client.callCommand(request, { meta: metadata, abort: abortController.signal });
+            this.subscriberStatus = SubscriberStatusEnum.ALIVE;
+            this.statusStream$.next(this.subscriberStatus);
+            call.responses.onMessage((update) => {
+                const message = RocosCommandMessage.fromModel(update);
+                emitter.next(message);
+                this.logger.debug('invokeRequest - on(data)', {
+                    message,
+                    projectId: params.projectId,
+                    callsign: params.callsign,
+                    commandId: params.commandId,
+                });
+            });
+            call.responses.onError((error) => {
+                this.logger.debug('invokeRequest - on(error)', {
+                    error,
+                    projectId: params.projectId,
+                    callsign: params.callsign,
+                    commandId: params.commandId,
+                });
+                emitter.error(error);
+            });
+            call.responses.onComplete(() => {
+                this.subscriberStatus = SubscriberStatusEnum.STOPPED;
+                this.statusStream$.next(this.subscriberStatus);
+                this.logger.debug('invokeRequest - on(end)', {
+                    projectId: params.projectId,
+                    callsign: params.callsign,
+                    commandId: params.commandId,
+                });
+                emitter.complete();
+            });
+            return () => {
+                this.logger.debug('unsubscribing commandStream');
+                abortController.abort();
+            };
+        });
+    }
+    getMetadata(projectId, callsign) {
+        return {
+            'authorization': this.token,
+            'r-p': projectId,
+            'r-cs': callsign,
+        };
+    }
+}

package/api/streams/command/CommandStreamAbstract.d.ts

@@ -0,0 +1,20 @@
+import { BehaviorSubject, Observable } from 'rxjs';
+import { ICommandParams, ICommandStream, IRocosCommandMessage, IStreamConfig, SubscriberStatusEnum } from '../../../models';
+import { CommandRequest } from '../../../grpc/rambo.v1_pb';
+import { Logger } from 'loglevel';
+export declare abstract class CommandStreamAbstract implements ICommandStream {
+    identifier: string;
+    statusStream$: BehaviorSubject<SubscriberStatusEnum>;
+    protected token: string;
+    private readonly scope;
+    protected url: string;
+    protected subscriberStatus: SubscriberStatusEnum;
+    protected logger: Logger;
+    protected constructor(config: IStreamConfig);
+    protected abstract callStream(request: CommandRequest, params: ICommandParams): Observable<IRocosCommandMessage>;
+    setToken(token: string): void;
+    stopStream(): void;
+    invokeRequest(params: ICommandParams): Observable<IRocosCommandMessage>;
+    private createCommandRequest;
+    private createRocosUriPath;
+}

package/api/streams/command/CommandStreamAbstract.js

@@ -0,0 +1,63 @@
+import { BehaviorSubject } from 'rxjs';
+import { ResponseLevelEnum, SubscriberStatusEnum, } from '../../../models';
+import { RocosUriPath, RocosUriScheme } from '../../../grpc/rambo.uri.v1_pb';
+import { CommandRequest } from '../../../grpc/rambo.v1_pb';
+import { IDENTIFIER_NAME_COMMAND } from '../../../constants/identifier';
+import { RocosStore } from '../../../store/RocosStore';
+import { StreamRegister } from '../../StreamRegister';
+import { filter } from 'rxjs/operators';
+import { getUnixTimeMs } from '../../../helpers/getUnixTimeMs';
+import { randomString } from '../../../helpers/randomString';
+export class CommandStreamAbstract {
+    constructor(config) {
+        this.subscriberStatus = SubscriberStatusEnum.STOPPED;
+        this.scope = config.scope;
+        this.identifier = StreamRegister.getIdentifier(IDENTIFIER_NAME_COMMAND, this.scope);
+        this.token = config.token;
+        this.url = config.url;
+        this.statusStream$ = new BehaviorSubject(SubscriberStatusEnum.STOPPED);
+        RocosStore.getChangeSubject()
+            .pipe(filter((message) => {
+            return message.type === 'token' && message.url === this.url;
+        }))
+            .subscribe((msg) => {
+            this.token = msg.data;
+        });
+    }
+    setToken(token) {
+        this.token = token;
+    }
+    stopStream() {
+        // do nothing for now
+    }
+    invokeRequest(params) {
+        if (params.timeoutMs === undefined || params.timeoutMs === null) {
+            params.timeoutMs = 30 * 1000; // Default 30 seconds.
+        }
+        this.logger.info('invokeRequest', params);
+        const request = this.createCommandRequest(params.projectId, params.callsign, params.commandId, params.parameters, params.timeoutMs, params.responseLevel);
+        return this.callStream(request, params);
+    }
+    createCommandRequest(projectId, callsign, commandId, parameters, timeoutMs = 30 * 1000, // Default 30 seconds.
+    responseLevel = ResponseLevelEnum.ALL) {
+        const path = this.createRocosUriPath(projectId, callsign, commandId);
+        return CommandRequest.create({
+            txid: randomString(),
+            uri: {
+                path,
+                scheme: RocosUriScheme.GRPC,
+            },
+            resLevel: responseLevel.valueOf(),
+            deadlineMs: getUnixTimeMs(timeoutMs).toString(),
+            parameters,
+        });
+    }
+    createRocosUriPath(projectId, callsign, commandId) {
+        return RocosUriPath.create({
+            callsign,
+            project: projectId,
+            component: 'command-executor',
+            topic: commandId,
+        });
+    }
+}

package/api/streams/command/CommandStreamNode.d.ts

@@ -0,0 +1,10 @@
+import { CommandRequest } from '../../../grpc/rambo.v1_pb';
+import { ICommandParams, IRocosCommandMessage, IStreamConfig } from '../../../models';
+import { Observable } from 'rxjs';
+import { CommandStreamAbstract } from './CommandStreamAbstract';
+export declare class CommandStreamNode extends CommandStreamAbstract {
+    private client;
+    constructor(config: IStreamConfig);
+    protected callStream(request: CommandRequest, params: ICommandParams): Observable<IRocosCommandMessage>;
+    private getMetadata;
+}