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

package/helpers/websandbox/frame/worker/worker.js

@@ -0,0 +1,74 @@
+const WHITELIST = [
+    'TEMPORARY',
+    'PERSISTENT',
+    'console',
+    'self',
+    'onmessage',
+    'postMessage',
+    'global',
+    'allowed',
+    'Array',
+    'Boolean',
+    'Date',
+    'Function',
+    'Number',
+    'Object',
+    'RegExp',
+    'String',
+    'Error',
+    'EvalError',
+    'RangeError',
+    'ReferenceError',
+    'SyntaxError',
+    'TypeError',
+    'URIError',
+    'decodeURI',
+    'decodeURIComponent',
+    'encodeURI',
+    'encodeURIComponent',
+    'isFinite',
+    'isNaN',
+    'parseFloat',
+    'parseInt',
+    'Infinity',
+    'JSON',
+    'Math',
+    'NaN',
+    'undefined',
+];
+const windowProps = Object.getOwnPropertyNames(self);
+const protoProps = Object.getOwnPropertyNames(self.__proto__);
+const props = [...windowProps, ...protoProps];
+props.forEach((prop) => {
+    if (!WHITELIST.includes(prop)) {
+        Object.defineProperty(self, prop, {
+            get: () => {
+                throw new Error(`Security Exception: cannot access ${prop}`);
+            },
+            set: () => {
+                throw new Error(`Security Exception: cannot set ${prop}`);
+            },
+            configurable: false,
+        });
+    }
+});
+// Parses and calls function string with args
+onmessage = (event) => {
+    let result;
+    let success = true;
+    try {
+        const fn = Function(event.data.contextVariable, `"use strict";return (${event.data.code});`);
+        result = fn(event.data.context);
+    }
+    catch (e) {
+        result = e;
+        success = false;
+    }
+    const message = {
+        id: event.data.id,
+        result,
+        success,
+    };
+    postMessage(message);
+};
+export {};

package/helpers/websandbox/frame/worker/worker.source.d.ts

@@ -0,0 +1,2 @@
+declare const source: string;
+export default source;

package/helpers/websandbox/frame/worker/worker.source.js

@@ -0,0 +1,4 @@
+// Auto-generated file
+/* eslint-disable */
+const source = `(()=>{"use strict";(()=>{const e=["TEMPORARY","PERSISTENT","console","self","onmessage","postMessage","global","allowed","Array","Boolean","Date","Function","Number","Object","RegExp","String","Error","EvalError","RangeError","ReferenceError","SyntaxError","TypeError","URIError","decodeURI","decodeURIComponent","encodeURI","encodeURIComponent","isFinite","isNaN","parseFloat","parseInt","Infinity","JSON","Math","NaN","undefined"];[...Object.getOwnPropertyNames(self),...Object.getOwnPropertyNames(self.__proto__)].forEach((r=>{e.includes(r)||Object.defineProperty(self,r,{get:()=>{throw new Error(\`Security Exception: cannot access \${r}\`)},set:()=>{throw new Error(\`Security Exception: cannot set \${r}\`)},configurable:!1})})),onmessage=e=>{let r,t=!0;try{r=Function(e.data.contextVariable,\`"use strict";return (\${e.data.code});\`)(e.data.context)}catch(e){r=e,t=!1}const o={id:e.data.id,result:r,success:t};postMessage(o)}})()})();`;
+export default source;

package/helpers/websandbox/index.d.ts

@@ -0,0 +1,2 @@
+import WebSandbox from './sandbox';
+export { WebSandbox };

package/helpers/websandbox/index.js

@@ -0,0 +1,2 @@
+import WebSandbox from './sandbox';
+export { WebSandbox };

package/helpers/websandbox/sandbox.d.ts

@@ -0,0 +1,57 @@
+export interface SandboxOptions extends Required<RunCodeOptions> {
+    /** The selector or element to append the iframe to */
+    frameContainer: string | Element;
+    /** Whether to enable verbose logging */
+    debugMode: boolean;
+}
+export interface RunCodeOptions {
+    /** The name of the variable to use for the context object */
+    contextVariable?: string;
+    timeout?: {
+        /** The minimum time to wait for a task to complete
+         *
+         * The worker will attempt to kill the task after this time.
+         */
+        minimumMs: number;
+        /** The maximum time to wait for a task to complete
+         *
+         * The sandbox will be destroyed and rebuilt after this time.
+         */
+        maximumMs: number;
+    };
+    abortSignal?: AbortSignal | null;
+}
+export declare const BaseOptions: SandboxOptions;
+export interface SandboxMethods {
+    iframeInitialised: () => void;
+}
+/** A sandbox for running untrusted code in an iframe & embedded web worker.
+ *
+ * This is a wrapper around the iframe and web worker that provides a simple API for running code in the sandbox.
+ * It also provides a context object that can be used to pass data into the sandbox.
+ */
+export default class WebSandbox {
+    private readonly options;
+    private frame;
+    private connection?;
+    private initialised;
+    private frameAbortController;
+    static new(options?: Partial<SandboxOptions>): Promise<WebSandbox>;
+    private constructor();
+    /** Runs code in the sandbox. Can be either a string or a function */
+    run<T = unknown>(code: string | (() => T), context?: unknown, options?: RunCodeOptions): Promise<T>;
+    /** Destroys the sandbox.
+     *
+     * This will remove the iframe from the DOM and remove the message listener.
+     */
+    destroy(): void;
+    private initialise;
+    private validateOptions;
+    private destroyAndRebuild;
+    private removeMessageListener;
+    private runFunction;
+    private runCode;
+    private promisifyAbortSignal;
+    private createFrame;
+    private prepareFrameContent;
+}

package/helpers/websandbox/sandbox.js

@@ -0,0 +1,175 @@
+import Connection from './connection';
+import frameSource from './frame';
+import { generateUUID } from '../generateUUID';
+export const BaseOptions = {
+    frameContainer: 'body',
+    debugMode: false,
+    contextVariable: 'ctx',
+    timeout: {
+        minimumMs: 1000,
+        maximumMs: 1500,
+    },
+    abortSignal: null,
+};
+/** A sandbox for running untrusted code in an iframe & embedded web worker.
+ *
+ * This is a wrapper around the iframe and web worker that provides a simple API for running code in the sandbox.
+ * It also provides a context object that can be used to pass data into the sandbox.
+ */
+export default class WebSandbox {
+    static async new(options = {}) {
+        const sandbox = new WebSandbox(options);
+        await sandbox.initialised;
+        return sandbox;
+    }
+    constructor(options) {
+        this.options = { ...BaseOptions, ...options };
+        this.frame = this.createFrame();
+        this.validateOptions(this.options);
+        this.initialised = this.initialise();
+        this.frameAbortController = new AbortController();
+        if (options.abortSignal) {
+            this.promisifyAbortSignal(options.abortSignal).catch(() => {
+                void this.destroyAndRebuild(this.frame.id);
+            });
+        }
+    }
+    /** Runs code in the sandbox. Can be either a string or a function */
+    async run(code, context, options) {
+        if (typeof code === 'function') {
+            return this.runFunction(code, context);
+        }
+        return this.runCode(code, context, options);
+    }
+    /** Destroys the sandbox.
+     *
+     * This will remove the iframe from the DOM and remove the message listener.
+     */
+    destroy() {
+        this.frameAbortController.abort();
+        this.frame.remove();
+        this.removeMessageListener();
+    }
+    initialise() {
+        return new Promise((resolve) => {
+            this.connection = new Connection('SANDBOX', this.frame.contentWindow.postMessage.bind(this.frame.contentWindow), {
+                iframeInitialised: () => resolve(),
+            }, (listener) => {
+                const sourceCheckListener = (event) => {
+                    if (event.source !== this.frame.contentWindow) {
+                        return;
+                    }
+                    return listener(event);
+                };
+                window.addEventListener('message', sourceCheckListener);
+                this.removeMessageListener = () => window.removeEventListener('message', sourceCheckListener);
+            }, { allowedSenderOrigin: 'null', debugMode: this.options.debugMode });
+        });
+    }
+    validateOptions(options) {
+        const minimumTimeout = options.timeout.minimumMs;
+        const maximumTimeout = options.timeout.maximumMs;
+        if (maximumTimeout < minimumTimeout) {
+            throw new Error(`maximum timeout (${maximumTimeout}ms) must be greater than or equal to minimum timeout (${minimumTimeout}ms)`);
+        }
+        if (minimumTimeout <= 0 || maximumTimeout <= 0) {
+            throw new Error('timeout values must be greater than 0');
+        }
+        if (maximumTimeout > 5000) {
+            throw new Error('maximum timeout must be less than or equal to 5000ms');
+        }
+    }
+    async destroyAndRebuild(frameId) {
+        if (this.frame.id !== frameId) {
+            return;
+        }
+        this.destroy();
+        this.frame = this.createFrame();
+        this.frameAbortController = new AbortController();
+        await this.initialise();
+    }
+    removeMessageListener() {
+        // replaced by constructor
+    }
+    async runFunction(fn, context, options) {
+        return this.runCode(`(${fn.toString()})()`, context, options);
+    }
+    async runCode(code, context, options) {
+        if (!this.connection) {
+            throw new Error('sandbox not initialised');
+        }
+        this.validateOptions({
+            ...this.options,
+            ...options,
+        });
+        const frameId = this.frame.id;
+        const timeout = this.promisifyAbortSignal(AbortSignal.timeout(options?.timeout?.maximumMs ?? this.options.timeout.maximumMs));
+        const frameAbortedSignal = this.promisifyAbortSignal(this.frameAbortController.signal);
+        const userAbortedSignal = options?.abortSignal ? this.promisifyAbortSignal(options.abortSignal) : null;
+        const taskId = generateUUID();
+        const task = this.connection.callRemoteMethod('startTask', {
+            id: taskId,
+            code,
+            context,
+            timeout: this.options.timeout.minimumMs,
+            contextVariable: options?.contextVariable ?? this.options.contextVariable,
+        });
+        const signals = [task, timeout, frameAbortedSignal, userAbortedSignal].filter((i) => i !== null);
+        return Promise.race(signals).catch(async (e) => {
+            if (e.name === 'TimeoutError') {
+                await this.destroyAndRebuild(frameId);
+            }
+            throw e;
+        });
+    }
+    promisifyAbortSignal(signal) {
+        return new Promise((_, reject) => {
+            // If the signal is already aborted, immediately throw in order to reject the promise.
+            if (signal.aborted) {
+                reject(signal.reason);
+            }
+            // Watch for 'abort' signals
+            signal.addEventListener('abort', () => {
+                // Stop the main operation
+                // Reject the promise with the abort reason.
+                reject(signal.reason);
+            });
+        });
+    }
+    createFrame() {
+        const containerSelector = this.options.frameContainer;
+        const container = typeof containerSelector === 'string' ? document.querySelector(containerSelector) : containerSelector;
+        if (!container) {
+            throw new Error('unable to find container for sandbox');
+        }
+        const iframe = document.createElement('iframe');
+        if (iframe.sandbox) {
+            iframe.sandbox.add('allow-scripts');
+        }
+        else {
+            iframe.setAttribute('sandbox', 'allow-scripts');
+        }
+        iframe.srcdoc = this.prepareFrameContent();
+        iframe.style.display = 'none';
+        iframe.id = generateUUID();
+        container.appendChild(iframe);
+        return iframe;
+    }
+    prepareFrameContent() {
+        let script = frameSource;
+        if (this.options.debugMode) {
+            script = `window.debugMode=true;${script}`;
+        }
+        return `
+      <!DOCTYPE html>
+      <html>
+        <head>
+          <meta charset="UTF-8">
+          <script>
+            ${script}
+          </script>
+        </head>
+      </html>
+    `;
+    }
+}

package/helpers/websandbox/types.d.ts

@@ -0,0 +1,13 @@
+type APIMethod = (...args: any[]) => unknown;
+export type API = Map<string, APIMethod>;
+export type APIDeclaration<T> = {
+    [K in keyof T]: T[K] extends APIMethod ? T[K] : never;
+};
+export interface Task {
+    id: string;
+    code: string;
+    context?: unknown;
+    timeout: number;
+    contextVariable?: string;
+}
+export {};

package/helpers/websandbox/types.js

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

package/index.d.ts

@@ -0,0 +1,7 @@
+export * from './constants/grpc';
+export * from './constants/timezones';
+export * from './helpers';
+export * from './models';
+export * from './services';
+export * from './IRocosSDK';
+export * from './RocosSDK';

package/index.js

@@ -0,0 +1,7 @@
+export * from './constants/grpc';
+export * from './constants/timezones';
+export * from './helpers';
+export * from './models';
+export * from './services';
+export * from './IRocosSDK';
+export * from './RocosSDK';

package/logger/RocosLogger.d.ts

@@ -0,0 +1,7 @@
+import { LogLevelDesc, Logger } from 'loglevel';
+export declare class RocosLogger {
+    static getInstance(name?: string): Logger;
+    static enableAll(): void;
+    static disableAll(): void;
+    static setLevel(level: LogLevelDesc): void;
+}

package/logger/RocosLogger.js

@@ -0,0 +1,37 @@
+import * as prefix from 'loglevel-plugin-prefix';
+import log from 'loglevel';
+log.setDefaultLevel('silent');
+prefix.reg(log);
+prefix.apply(log, {
+    format(level, name, timestamp) {
+        return `[${timestamp}] ${level.toUpperCase()} ${name}:`;
+    },
+});
+export class RocosLogger {
+    static getInstance(name) {
+        if (name) {
+            const logger = log.getLogger(name);
+            logger.setLevel(log.getLevel());
+            return logger;
+        }
+        return log;
+    }
+    static enableAll() {
+        log.enableAll();
+        for (const name in log.getLoggers()) {
+            log.getLogger(name).enableAll();
+        }
+    }
+    static disableAll() {
+        log.disableAll();
+        for (const name in log.getLoggers()) {
+            log.getLogger(name).disableAll();
+        }
+    }
+    static setLevel(level) {
+        log.setLevel(level);
+        for (const name in log.getLoggers()) {
+            log.getLogger(name).setLevel(log.getLevel());
+        }
+    }
+}

package/models/CallsignStatus.d.ts

@@ -0,0 +1,6 @@
+export declare enum CallsignStatus {
+    UNKNOWN = "unknown",
+    ONLINE = "online",
+    OFFLINE = "offline",
+    ERROR = "error"
+}

package/models/CallsignStatus.js

@@ -0,0 +1,7 @@
+export var CallsignStatus;
+(function (CallsignStatus) {
+    CallsignStatus["UNKNOWN"] = "unknown";
+    CallsignStatus["ONLINE"] = "online";
+    CallsignStatus["OFFLINE"] = "offline";
+    CallsignStatus["ERROR"] = "error";
+})(CallsignStatus || (CallsignStatus = {}));

package/models/ExportDataQuery.d.ts

@@ -0,0 +1,8 @@
+import { IExportDataQuery, IExportDataQueryFilter } from './IExportDataQuery';
+export declare class ExportDataQuery implements IExportDataQuery {
+    startDate: Date;
+    endDate: Date;
+    filters: IExportDataQueryFilter[];
+    constructor(init?: Partial<IExportDataQuery>);
+    toJSON(): any;
+}

package/models/ExportDataQuery.js

@@ -0,0 +1,13 @@
+export class ExportDataQuery {
+    constructor(init) {
+        this.filters = [];
+        Object.assign(this, init);
+    }
+    toJSON() {
+        return {
+            startDate: this.startDate ? this.startDate.getTime() : null,
+            endDate: this.endDate ? this.endDate.getTime() : null,
+            filters: this.filters,
+        };
+    }
+}

package/models/ExternalProject.d.ts

@@ -0,0 +1,6 @@
+export declare class ExternalProject {
+    id?: string;
+    name?: string;
+    createdAt?: number;
+    isLinked?: boolean;
+}

package/models/ExternalProject.js

@@ -0,0 +1,2 @@
+export class ExternalProject {
+}

package/models/IBaseService.d.ts

@@ -0,0 +1,4 @@
+export interface IBaseService {
+    getStatus: () => boolean;
+    teardown?: (() => void) | (() => Promise<void>);
+}

package/models/IBaseService.js

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

package/models/IConfigGroup.d.ts

@@ -0,0 +1,5 @@
+export interface IConfigGroup {
+    id: string;
+    name: string;
+    config: any[];
+}

package/models/IConfigGroup.js

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

package/models/IDebugLevel.d.ts

@@ -0,0 +1,2 @@
+import { LogLevelDesc } from 'loglevel';
+export type IDebugLevel = LogLevelDesc;

package/models/IDebugLevel.js

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

package/models/IExportDataQuery.d.ts

@@ -0,0 +1,9 @@
+export interface IExportDataQueryFilter {
+    keyword: string;
+    ids: string[];
+}
+export interface IExportDataQuery {
+    startDate: Date;
+    endDate: Date;
+    filters: IExportDataQueryFilter[];
+}

package/models/IExportDataQuery.js

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

package/models/IFunctionConfig.d.ts

@@ -0,0 +1,8 @@
+export interface IFunctionConfig {
+    id: string;
+    name: string;
+    handler: string;
+    runtime: string;
+    function: string;
+    deps: string[];
+}

package/models/IFunctionConfig.js

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

package/models/IInvitation.d.ts

@@ -0,0 +1,6 @@
+export type IInvitationType = 'PROJECT' | 'SIGNUP';
+export interface IInvitation {
+    email: string;
+    type: IInvitationType;
+    ids: string[];
+}

package/models/IInvitation.js

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

package/models/IInvitationExists.d.ts

@@ -0,0 +1,4 @@
+export interface IInvitationExists {
+    accountExists: boolean;
+    accepted: boolean;
+}

package/models/IInvitationExists.js

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

package/models/IOperation.d.ts

@@ -0,0 +1,6 @@
+export interface IOperation {
+    name: string;
+    pageType: string;
+    payload?: string;
+    description?: string;
+}

package/models/IOperation.js

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

package/models/IPersonalAccessToken.d.ts

@@ -0,0 +1,16 @@
+export interface IPersonalAccessToken {
+    name: string;
+    pat?: string;
+    ttlDays: number;
+    scope: string[];
+    projectId: string;
+    robotDefinitionId?: string;
+    metaData: IPersonalAccessTokenMetadata;
+    expiry?: Date;
+}
+interface IPersonalAccessTokenMetadata {
+    singleUse?: boolean;
+    defaultRobotDefinitionId?: string;
+    [key: string]: unknown;
+}
+export {};

package/models/IPersonalAccessToken.js

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

package/models/IProject.d.ts

@@ -0,0 +1,4 @@
+export interface IProject {
+    name: string;
+    description: string;
+}

package/models/IProject.js

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

package/models/IProjectApplication.d.ts

@@ -0,0 +1,6 @@
+export interface IProjectApplication {
+    id?: string;
+    name: string;
+    secret?: string;
+    tokenExpiryInMinutes: number;
+}

package/models/IProjectApplication.js

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

package/models/IRobot.d.ts

@@ -0,0 +1,18 @@
+import { RobotModeType } from './types';
+export interface IRobot {
+    tags?: string[];
+    name: string;
+    callsign: string;
+    disabled: boolean;
+    imageId: string;
+    mode: RobotModeType;
+    description?: string;
+    configParameters?: string;
+    robotDefinition?: string;
+    projectId?: string;
+    componentSettingsVersionLog?: string[];
+    createdAt?: string;
+    updatedAt?: string;
+    robotDefinitionName?: string;
+    robotDefinitionTags?: string[];
+}

package/models/IRobot.js

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

package/models/IRobotConfig.d.ts

@@ -0,0 +1,8 @@
+export interface IRobotConfig {
+    id: string;
+    name: string;
+    description: string;
+    type: string;
+    defaultValue: any;
+    required: boolean;
+}

package/models/IRobotConfig.js

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

package/models/IRobotPlugin.d.ts

@@ -0,0 +1,3 @@
+export interface IRobotPlugin {
+    name: string;
+}

package/models/IRobotPlugin.js

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

package/models/IRobotSettings.d.ts

@@ -0,0 +1,28 @@
+export interface IRobotSettings {
+    type: "settings";
+    items: {
+        id: string;
+        value: {
+            /**
+             * The actual settings object for this specific setting type
+             */
+            settings: Record<string, any>;
+            /**
+             * The ID of the setting type, usually one of: ops-global-settings, ops-local-settings, flight-app-settings
+             */
+            id: 'ops-global-settings' | 'ops-local-settings' | 'flight-app-settings' | string;
+            enabled: boolean;
+        };
+    }[];
+    version: number;
+    robotDefinitionId: string;
+    username: string;
+    /**
+     * Date in ISO format
+     */
+    createdAt: string;
+    /**
+     * Date in ISO format
+     */
+    updatedAt: string;
+}