@scrypted/server 0.7.93 → 0.7.95

package/dist/plugin/acl.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AccessControls = void 0;
+/**
+ * Scrypted Access Controls allow selective reading of state, subscription to evemts,
+ * and invocation of methods.
+ * Everything else should be rejected.
+ */
+class AccessControls {
+    acl;
+    constructor(acl) {
+        this.acl = acl;
+    }
+    deny(reason = 'User does not have permission') {
+        throw new Error(reason);
+    }
+    shouldRejectDevice(id) {
+        if (this.acl.devicesAccessControls === null)
+            return false;
+        if (!this.acl.devicesAccessControls)
+            return true;
+        const dacls = this.acl.devicesAccessControls.filter(dacl => dacl.id === id);
+        return !dacls.length;
+    }
+    shouldRejectProperty(id, property) {
+        if (this.acl.devicesAccessControls === null)
+            return false;
+        if (!this.acl.devicesAccessControls)
+            return true;
+        const dacls = this.acl.devicesAccessControls.filter(dacl => dacl.id === id);
+        for (const dacl of dacls) {
+            if (!dacl.properties || dacl.properties.includes(property))
+                return false;
+        }
+        return true;
+    }
+    shouldRejectEvent(id, eventDetails) {
+        if (this.acl.devicesAccessControls === null)
+            return false;
+        if (!this.acl.devicesAccessControls)
+            return true;
+        const dacls = this.acl.devicesAccessControls.filter(dacl => dacl.id === id);
+        const { property } = eventDetails;
+        if (property) {
+            for (const dacl of dacls) {
+                if (!dacl.properties || dacl.properties.includes(property))
+                    return false;
+            }
+        }
+        const { eventInterface } = eventDetails;
+        for (const dacl of dacls) {
+            if (!dacl.interfaces || dacl.interfaces.includes(eventInterface))
+                return false;
+        }
+        return true;
+    }
+    shouldRejectInterface(id, scryptedInterface) {
+        if (this.acl.devicesAccessControls === null)
+            return false;
+        if (!this.acl.devicesAccessControls)
+            return true;
+        const dacls = this.acl.devicesAccessControls.filter(dacl => dacl.id === id);
+        for (const dacl of dacls) {
+            if (!dacl.interfaces || dacl.interfaces.includes(scryptedInterface))
+                return false;
+        }
+        return true;
+    }
+    shouldRejectMethod(id, method) {
+        if (this.acl.devicesAccessControls === null)
+            return false;
+        if (!this.acl.devicesAccessControls)
+            return true;
+        const dacls = this.acl.devicesAccessControls.filter(dacl => dacl.id === id);
+        for (const dacl of dacls) {
+            if (!dacl.methods || dacl.methods.includes(method))
+                return false;
+        }
+        return true;
+    }
+}
+exports.AccessControls = AccessControls;
+//# sourceMappingURL=acl.js.map

package/dist/plugin/acl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"acl.js","sourceRoot":"","sources":["../../src/plugin/acl.ts"],"names":[],"mappings":"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"}

package/dist/plugin/descriptor.d.ts

@@ -0,0 +1,22 @@
+import { ScryptedInterface, ScryptedInterfaceDescriptor } from "@scrypted/types";
+export declare const allInterfaceProperties: string[];
+export declare function getPropertyInterfaces(descriptors: {
+    [scryptedInterface: string]: ScryptedInterfaceDescriptor;
+}): {
+    [property: string]: ScryptedInterface;
+};
+export declare const propertyInterfaces: {
+    [property: string]: ScryptedInterface;
+};
+export declare function getInterfaceMethods(descriptors: {
+    [scryptedInterface: string]: ScryptedInterfaceDescriptor;
+}, interfaces: Set<string>): string[];
+export declare function getInterfaceProperties(descriptors: {
+    [scryptedInterface: string]: ScryptedInterfaceDescriptor;
+}, interfaces: Set<string>): string[];
+export declare function isValidInterfaceMethod(descriptors: {
+    [scryptedInterface: string]: ScryptedInterfaceDescriptor;
+}, interfaces: Set<string>, method: string): boolean;
+export declare function isValidInterfaceProperty(descriptors: {
+    [scryptedInterface: string]: ScryptedInterfaceDescriptor;
+}, interfaces: string[], property: string): boolean;

package/dist/plugin/descriptor.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isValidInterfaceProperty = exports.isValidInterfaceMethod = exports.getInterfaceProperties = exports.getInterfaceMethods = exports.propertyInterfaces = exports.getPropertyInterfaces = exports.allInterfaceProperties = void 0;
+const types_1 = require("@scrypted/types");
+exports.allInterfaceProperties = [].concat(...Object.values(types_1.ScryptedInterfaceDescriptors).map(type => type.properties));
+function getPropertyInterfaces(descriptors) {
+    const propertyInterfaces = {};
+    for (const descriptor of Object.values(descriptors)) {
+        for (const property of descriptor.properties) {
+            propertyInterfaces[property] = descriptor.name;
+        }
+    }
+    return propertyInterfaces;
+}
+exports.getPropertyInterfaces = getPropertyInterfaces;
+exports.propertyInterfaces = getPropertyInterfaces(types_1.ScryptedInterfaceDescriptors);
+function getInterfaceMethods(descriptors, interfaces) {
+    return Object.values(descriptors).filter(e => interfaces.has(e.name)).map(type => type.methods).flat();
+}
+exports.getInterfaceMethods = getInterfaceMethods;
+function getInterfaceProperties(descriptors, interfaces) {
+    return Object.values(descriptors).filter(e => interfaces.has(e.name)).map(type => type.properties).flat();
+}
+exports.getInterfaceProperties = getInterfaceProperties;
+function isValidInterfaceMethod(descriptors, interfaces, method) {
+    const availableMethods = getInterfaceMethods(descriptors, interfaces);
+    return availableMethods.includes(method) || descriptors[types_1.ScryptedInterface.ScryptedDevice].methods.includes(method);
+}
+exports.isValidInterfaceMethod = isValidInterfaceMethod;
+function isValidInterfaceProperty(descriptors, interfaces, property) {
+    const availableProperties = getInterfaceProperties(descriptors, new Set(interfaces));
+    return availableProperties.includes(property);
+}
+exports.isValidInterfaceProperty = isValidInterfaceProperty;
+//# sourceMappingURL=descriptor.js.map

package/dist/plugin/descriptor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"descriptor.js","sourceRoot":"","sources":["../../src/plugin/descriptor.ts"],"names":[],"mappings":";;;AAAA,2CAA+G;AAElG,QAAA,sBAAsB,GAAa,EAAE,CAAC,MAAM,CAAC,GAAG,MAAM,CAAC,MAAM,CAAC,oCAA4B,CAAC,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC;AAEvI,SAAgB,qBAAqB,CAAC,WAAyE;IAC3G,MAAM,kBAAkB,GAA8C,EAAE,CAAC;IAEzE,KAAK,MAAM,UAAU,IAAI,MAAM,CAAC,MAAM,CAAC,WAAW,CAAC,EAAE;QACjD,KAAK,MAAM,QAAQ,IAAI,UAAU,CAAC,UAAU,EAAE;YAC1C,kBAAkB,CAAC,QAAQ,CAAC,GAAG,UAAU,CAAC,IAAyB,CAAC;SACvE;KACJ;IAED,OAAO,kBAAkB,CAAC;AAC9B,CAAC;AAVD,sDAUC;AAEY,QAAA,kBAAkB,GAAG,qBAAqB,CAAC,oCAA4B,CAAC,CAAC;AAEtF,SAAgB,mBAAmB,CAAC,WAAyE,EAAE,UAAuB;IAClI,OAAO,MAAM,CAAC,MAAM,CAAC,WAAW,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,IAAI,EAAE,CAAC;AAC3G,CAAC;AAFD,kDAEC;AAED,SAAgB,sBAAsB,CAAC,WAAyE,EAAE,UAAuB;IACrI,OAAO,MAAM,CAAC,MAAM,CAAC,WAAW,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC,IAAI,EAAE,CAAC;AAC9G,CAAC;AAFD,wDAEC;AAED,SAAgB,sBAAsB,CAAC,WAAyE,EAAE,UAAuB,EAAE,MAAc;IACrJ,MAAM,gBAAgB,GAAG,mBAAmB,CAAC,WAAW,EAAE,UAAU,CAAC,CAAC;IACtE,OAAO,gBAAgB,CAAC,QAAQ,CAAC,MAAM,CAAC,IAAI,WAAW,CAAC,yBAAiB,CAAC,cAAc,CAAC,CAAC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC;AACvH,CAAC;AAHD,wDAGC;AAED,SAAgB,wBAAwB,CAAC,WAAyE,EAAE,UAAoB,EAAE,QAAgB;IACtJ,MAAM,mBAAmB,GAAG,sBAAsB,CAAC,WAAW,EAAE,IAAI,GAAG,CAAC,UAAU,CAAC,CAAC,CAAC;IACrF,OAAO,mBAAmB,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC;AAClD,CAAC;AAHD,4DAGC"}

package/dist/plugin/media.d.ts

@@ -0,0 +1,71 @@
+/// <reference types="node" />
+import { BufferConverter, DeviceManager, FFmpegInput, MediaManager, MediaObject as MediaObjectInterface, MediaObjectOptions, ScryptedDevice, ScryptedNativeId, SystemDeviceState, SystemManager } from "@scrypted/types";
+import { MediaObjectRemote } from "./plugin-api";
+type IdBufferConverter = BufferConverter & {
+    id: string;
+    name: string;
+};
+export declare abstract class MediaManagerBase implements MediaManager {
+    builtinConverters: IdBufferConverter[];
+    extraConverters: IdBufferConverter[];
+    constructor();
+    addConverter(converter: IdBufferConverter): Promise<void>;
+    clearConverters(): Promise<void>;
+    convertMediaObjectToJSON<T>(mediaObject: MediaObjectInterface, toMimeType: string): Promise<T>;
+    abstract getSystemState(): {
+        [id: string]: {
+            [property: string]: SystemDeviceState;
+        };
+    };
+    abstract getDeviceById<T>(id: string): T & ScryptedDevice;
+    abstract getPluginDeviceId(): string;
+    abstract getMixinConsole(mixinId: string, nativeId: ScryptedNativeId): Console;
+    getFFmpegPath(): Promise<string>;
+    getFilesPath(): Promise<string>;
+    getConverters(): IdBufferConverter[];
+    ensureMediaObjectRemote(mediaObject: string | MediaObjectInterface): MediaObjectRemote;
+    convertMediaObject<T>(mediaObject: MediaObjectInterface, toMimeType: string): Promise<T>;
+    convertMediaObjectToInsecureLocalUrl(mediaObject: string | MediaObjectInterface, toMimeType: string): Promise<string>;
+    convertMediaObjectToBuffer(mediaObject: MediaObjectInterface, toMimeType: string): Promise<Buffer>;
+    convertMediaObjectToLocalUrl(mediaObject: string | MediaObjectInterface, toMimeType: string): Promise<string>;
+    convertMediaObjectToUrl(mediaObject: string | MediaObjectInterface, toMimeType: string): Promise<string>;
+    createMediaObjectRemote<T extends MediaObjectOptions>(data: any | Buffer | Promise<string | Buffer>, mimeType: string, options?: T): MediaObjectRemote & T;
+    createFFmpegMediaObject(ffMpegInput: FFmpegInput, options?: MediaObjectOptions): Promise<MediaObjectInterface>;
+    createMediaObjectFromUrl(data: string, options?: MediaObjectOptions): Promise<MediaObjectInterface>;
+    createMediaObject<T extends MediaObjectOptions>(data: any, mimeType: string, options?: T): Promise<MediaObjectInterface & T>;
+    convert(converters: IdBufferConverter[], mediaObject: MediaObjectRemote, toMimeType: string): Promise<{
+        data: Buffer | string | any;
+        mimeType: string;
+    }>;
+}
+export declare class MediaManagerImpl extends MediaManagerBase {
+    systemManager: SystemManager;
+    deviceManager: DeviceManager;
+    constructor(systemManager: SystemManager, deviceManager: DeviceManager);
+    getSystemState(): {
+        [id: string]: {
+            [property: string]: SystemDeviceState;
+        };
+    };
+    getDeviceById<T>(id: string): T;
+    getPluginDeviceId(): string;
+    getMixinConsole(mixinId: string, nativeId: string): Console;
+}
+export declare class MediaManagerHostImpl extends MediaManagerBase {
+    pluginDeviceId: string;
+    getSystemState: () => {
+        [id: string]: {
+            [property: string]: SystemDeviceState;
+        };
+    };
+    console: Console;
+    getDeviceById: (id: string) => any;
+    constructor(pluginDeviceId: string, getSystemState: () => {
+        [id: string]: {
+            [property: string]: SystemDeviceState;
+        };
+    }, console: Console, getDeviceById: (id: string) => any);
+    getPluginDeviceId(): string;
+    getMixinConsole(mixinId: string, nativeId: string): Console;
+}
+export {};

package/dist/plugin/media.js

@@ -0,0 +1,420 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MediaManagerHostImpl = exports.MediaManagerImpl = exports.MediaManagerBase = void 0;
+const types_1 = require("@scrypted/types");
+const axios_1 = __importDefault(require("axios"));
+const ffmpeg_static_1 = __importDefault(require("ffmpeg-static"));
+const fs_1 = __importDefault(require("fs"));
+const https_1 = __importDefault(require("https"));
+const mime_1 = __importDefault(require("mime"));
+const mkdirp_1 = __importDefault(require("mkdirp"));
+const node_dijkstra_1 = __importDefault(require("node-dijkstra"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const whatwg_mimetype_1 = __importDefault(require("whatwg-mimetype"));
+const mediaobject_1 = require("./mediaobject");
+function typeMatches(target, candidate) {
+    // candidate will accept anything
+    if (candidate === '*' || target === '*')
+        return true;
+    return target === candidate;
+}
+function mimeMatches(target, candidate) {
+    return typeMatches(target.type, candidate.type) && typeMatches(target.subtype, candidate.subtype);
+}
+const httpsAgent = new https_1.default.Agent({
+    rejectUnauthorized: false
+});
+function getBuiltinId(n) {
+    return 'builtin-' + n;
+}
+function getExtraId(n) {
+    return 'extra-' + n;
+}
+class MediaManagerBase {
+    builtinConverters = [];
+    extraConverters = [];
+    constructor() {
+        for (const h of ['http', 'https']) {
+            this.builtinConverters.push({
+                id: getBuiltinId(this.builtinConverters.length),
+                name: 'HTTP Converter',
+                fromMimeType: types_1.ScryptedMimeTypes.SchemePrefix + h,
+                toMimeType: types_1.ScryptedMimeTypes.MediaObject,
+                convert: async (data, fromMimeType, toMimeType) => {
+                    const ab = await axios_1.default.get(data.toString(), {
+                        responseType: 'arraybuffer',
+                        httpsAgent,
+                    });
+                    const mimeType = ab.headers['content-type'] || toMimeType;
+                    const mo = this.createMediaObject(Buffer.from(ab.data), mimeType);
+                    return mo;
+                }
+            });
+        }
+        this.builtinConverters.push({
+            id: getBuiltinId(this.builtinConverters.length),
+            name: 'File Converter',
+            fromMimeType: types_1.ScryptedMimeTypes.SchemePrefix + 'file',
+            toMimeType: types_1.ScryptedMimeTypes.MediaObject,
+            convert: async (data, fromMimeType, toMimeType) => {
+                const url = data.toString();
+                const filename = url.substring('file:'.length);
+                if (toMimeType === types_1.ScryptedMimeTypes.FFmpegInput) {
+                    const ffmpegInput = {
+                        url,
+                        inputArguments: [
+                            '-i', filename,
+                        ]
+                    };
+                    return this.createFFmpegMediaObject(ffmpegInput);
+                }
+                const ab = await fs_1.default.promises.readFile(filename);
+                const mt = mime_1.default.getType(data.toString());
+                const mo = this.createMediaObject(ab, mt);
+                return mo;
+            }
+        });
+        this.builtinConverters.push({
+            id: getBuiltinId(this.builtinConverters.length),
+            name: 'Url to FFmpegInput Converter',
+            fromMimeType: types_1.ScryptedMimeTypes.Url,
+            toMimeType: types_1.ScryptedMimeTypes.FFmpegInput,
+            async convert(data, fromMimeType) {
+                const url = data.toString();
+                const args = {
+                    url,
+                    inputArguments: [
+                        '-i', url,
+                    ],
+                };
+                return Buffer.from(JSON.stringify(args));
+            }
+        });
+        this.builtinConverters.push({
+            id: getBuiltinId(this.builtinConverters.length),
+            name: 'FFmpegInput to MediaStreamUrl Converter',
+            fromMimeType: types_1.ScryptedMimeTypes.FFmpegInput,
+            toMimeType: types_1.ScryptedMimeTypes.MediaStreamUrl,
+            async convert(data, fromMimeType) {
+                return data;
+            }
+        });
+        this.builtinConverters.push({
+            id: getBuiltinId(this.builtinConverters.length),
+            name: 'MediaStreamUrl to FFmpegInput Converter',
+            fromMimeType: types_1.ScryptedMimeTypes.MediaStreamUrl,
+            toMimeType: types_1.ScryptedMimeTypes.FFmpegInput,
+            async convert(data, fromMimeType) {
+                const mediaUrl = JSON.parse(data.toString());
+                const inputArguments = [
+                    '-i', mediaUrl.url,
+                ];
+                const ret = Object.assign({
+                    inputArguments,
+                }, mediaUrl);
+                if (mediaUrl.url.startsWith('rtsp')) {
+                    ret.container = 'rtsp';
+                    inputArguments.unshift("-rtsp_transport", "tcp");
+                }
+                return Buffer.from(JSON.stringify(ret));
+            }
+        });
+        // todo: move this to snapshot plugin
+        this.builtinConverters.push({
+            id: getBuiltinId(this.builtinConverters.length),
+            name: 'Image Converter',
+            fromMimeType: 'image/*',
+            toMimeType: 'image/*',
+            convert: async (data, fromMimeType) => {
+                return data;
+            }
+        });
+    }
+    async addConverter(converter) {
+        converter.id = getExtraId(this.extraConverters.length);
+        this.extraConverters.push(converter);
+    }
+    async clearConverters() {
+        this.extraConverters = [];
+    }
+    async convertMediaObjectToJSON(mediaObject, toMimeType) {
+        const buffer = await this.convertMediaObjectToBuffer(mediaObject, toMimeType);
+        return JSON.parse(buffer.toString());
+    }
+    async getFFmpegPath() {
+        // try to get the ffmpeg path as a value of another variable
+        // ie, in docker builds:
+        //     export SCRYPTED_FFMPEG_PATH_ENV_VARIABLE=SCRYPTED_RASPBIAN_FFMPEG_PATH
+        const v = process.env.SCRYPTED_FFMPEG_PATH_ENV_VARIABLE;
+        if (v) {
+            const f = process.env[v];
+            if (f && fs_1.default.existsSync(f))
+                return f;
+        }
+        // try to get the ffmpeg path from a variable
+        // ie:
+        //     export SCRYPTED_FFMPEG_PATH=/usr/local/bin/ffmpeg
+        const f = process.env.SCRYPTED_FFMPEG_PATH;
+        if (f && fs_1.default.existsSync(f))
+            return f;
+        const defaultPath = os_1.default.platform() === 'win32' ? 'ffmpeg.exe' : 'ffmpeg';
+        return ffmpeg_static_1.default || defaultPath;
+    }
+    async getFilesPath() {
+        const filesPath = process.env.SCRYPTED_PLUGIN_VOLUME;
+        if (!filesPath)
+            throw new Error('SCRYPTED_PLUGIN_VOLUME env variable not set?');
+        const ret = path_1.default.join(filesPath, 'files');
+        mkdirp_1.default.sync(ret);
+        return ret;
+    }
+    getConverters() {
+        const converters = Object.entries(this.getSystemState())
+            .filter(([id, state]) => state[types_1.ScryptedInterfaceProperty.interfaces]?.value?.includes(types_1.ScryptedInterface.BufferConverter))
+            .map(([id]) => {
+            const device = this.getDeviceById(id);
+            return {
+                id,
+                name: device.name,
+                fromMimeType: device.fromMimeType,
+                toMimeType: device.toMimeType,
+                convert(data, fromMimeType, toMimeType, options) {
+                    return device.convert(data, fromMimeType, toMimeType, options);
+                },
+            };
+        });
+        // builtins should be after system converters. these should not be overriden by system,
+        // as it could cause system instability with misconfiguration.
+        converters.push(...this.builtinConverters);
+        // extra converters are added last and do allow overriding builtins, as
+        // the instability would be confined to a single plugin.
+        converters.push(...this.extraConverters);
+        return converters;
+    }
+    ensureMediaObjectRemote(mediaObject) {
+        if (typeof mediaObject === 'string') {
+            const mime = mime_1.default.getType(mediaObject);
+            return this.createMediaObjectRemote(mediaObject, mime);
+        }
+        return mediaObject;
+    }
+    async convertMediaObject(mediaObject, toMimeType) {
+        const converted = await this.convert(this.getConverters(), this.ensureMediaObjectRemote(mediaObject), toMimeType);
+        return converted.data;
+    }
+    async convertMediaObjectToInsecureLocalUrl(mediaObject, toMimeType) {
+        const intermediate = await this.convert(this.getConverters(), this.ensureMediaObjectRemote(mediaObject), toMimeType);
+        const converted = this.createMediaObjectRemote(intermediate.data, intermediate.mimeType);
+        const url = await this.convert(this.getConverters(), converted, types_1.ScryptedMimeTypes.InsecureLocalUrl);
+        return url.data.toString();
+    }
+    async convertMediaObjectToBuffer(mediaObject, toMimeType) {
+        const intermediate = await this.convert(this.getConverters(), this.ensureMediaObjectRemote(mediaObject), toMimeType);
+        return intermediate.data;
+    }
+    async convertMediaObjectToLocalUrl(mediaObject, toMimeType) {
+        const intermediate = await this.convert(this.getConverters(), this.ensureMediaObjectRemote(mediaObject), toMimeType);
+        const converted = this.createMediaObjectRemote(intermediate.data, intermediate.mimeType);
+        const url = await this.convert(this.getConverters(), converted, types_1.ScryptedMimeTypes.LocalUrl);
+        return url.data.toString();
+    }
+    async convertMediaObjectToUrl(mediaObject, toMimeType) {
+        const intermediate = await this.convert(this.getConverters(), this.ensureMediaObjectRemote(mediaObject), toMimeType);
+        const converted = this.createMediaObjectRemote(intermediate.data, intermediate.mimeType);
+        const url = await this.convert(this.getConverters(), converted, types_1.ScryptedMimeTypes.Url);
+        return url.data.toString();
+    }
+    createMediaObjectRemote(data, mimeType, options) {
+        if (typeof data === 'string')
+            throw new Error('string is not a valid type. if you intended to send a url, use createMediaObjectFromUrl.');
+        if (!mimeType)
+            throw new Error('no mimeType provided');
+        if (mimeType === types_1.ScryptedMimeTypes.MediaObject)
+            return data;
+        if (data.constructor?.name === Object.name)
+            data = Buffer.from(JSON.stringify(data));
+        const sourceId = typeof options?.sourceId === 'string' ? options?.sourceId : this.getPluginDeviceId();
+        if (sourceId) {
+            options ||= {};
+            options.sourceId = sourceId;
+        }
+        return new mediaobject_1.MediaObject(mimeType, data, options);
+    }
+    async createFFmpegMediaObject(ffMpegInput, options) {
+        return this.createMediaObjectRemote(Buffer.from(JSON.stringify(ffMpegInput)), types_1.ScryptedMimeTypes.FFmpegInput, options);
+    }
+    async createMediaObjectFromUrl(data, options) {
+        const url = new URL(data);
+        const scheme = url.protocol.slice(0, -1);
+        const mimeType = types_1.ScryptedMimeTypes.SchemePrefix + scheme;
+        const sourceId = typeof options?.sourceId === 'string' ? options?.sourceId : this.getPluginDeviceId();
+        class MediaObjectImpl {
+            __proxy_props = {
+                mimeType,
+                sourceId,
+            };
+            mimeType = mimeType;
+            sourceId = sourceId;
+            async getData() {
+                return Promise.resolve(data);
+            }
+        }
+        return new MediaObjectImpl();
+    }
+    async createMediaObject(data, mimeType, options) {
+        return this.createMediaObjectRemote(data, mimeType, options);
+    }
+    async convert(converters, mediaObject, toMimeType) {
+        // console.log('converting', mediaObject.mimeType, toMimeType);
+        const mediaMime = new whatwg_mimetype_1.default(mediaObject.mimeType);
+        const outputMime = new whatwg_mimetype_1.default(toMimeType);
+        if (mimeMatches(mediaMime, outputMime)) {
+            return {
+                mimeType: outputMime.essence,
+                data: await mediaObject.getData(),
+            };
+        }
+        let sourceId = mediaObject?.sourceId;
+        if (typeof sourceId !== 'string')
+            sourceId = this.getPluginDeviceId();
+        const console = this.getMixinConsole(sourceId, undefined);
+        const converterMap = new Map();
+        for (const c of converters) {
+            converterMap.set(c.id, c);
+        }
+        const nodes = {};
+        const mediaNode = {};
+        nodes['mediaObject'] = mediaNode;
+        nodes['output'] = {};
+        for (const converter of converters) {
+            try {
+                const inputMime = new whatwg_mimetype_1.default(converter.fromMimeType);
+                const convertedMime = new whatwg_mimetype_1.default(converter.toMimeType);
+                // catch all converters should be heavily weighted so as not to use them.
+                const inputWeight = parseFloat(inputMime.parameters.get('converter-weight')) || (inputMime.essence === '*/*' ? 1000 : 1);
+                // const convertedWeight = parseFloat(convertedMime.parameters.get('converter-weight')) || (convertedMime.essence === ScryptedMimeTypes.MediaObject ? 1000 : 1);
+                // const conversionWeight = inputWeight + convertedWeight;
+                const targetId = converter.id;
+                const node = nodes[targetId] = {};
+                // edge matches
+                for (const candidate of converters) {
+                    try {
+                        const candidateMime = new whatwg_mimetype_1.default(candidate.fromMimeType);
+                        if (!mimeMatches(convertedMime, candidateMime))
+                            continue;
+                        const outputWeight = parseFloat(candidateMime.parameters.get('converter-weight')) || (candidateMime.essence === '*/*' ? 1000 : 1);
+                        const candidateId = candidate.id;
+                        node[candidateId] = inputWeight + outputWeight;
+                    }
+                    catch (e) {
+                        console.warn(candidate.name, 'skipping converter due to error', e);
+                    }
+                }
+                // source matches
+                if (mimeMatches(mediaMime, inputMime)) {
+                    mediaNode[targetId] = inputWeight;
+                }
+                // target output matches
+                if (mimeMatches(outputMime, convertedMime) || converter.toMimeType === types_1.ScryptedMimeTypes.MediaObject) {
+                    node['output'] = inputWeight;
+                }
+            }
+            catch (e) {
+                console.warn('skipping converter due to error', e);
+            }
+        }
+        const graph = new node_dijkstra_1.default();
+        for (const id of Object.keys(nodes)) {
+            graph.addNode(id, nodes[id]);
+        }
+        const route = graph.path('mediaObject', 'output');
+        if (!route || !route.length)
+            throw new Error(`no converter found: ${mediaObject?.mimeType} to ${toMimeType}`);
+        // pop off the mediaObject start node, no conversion necessary.
+        route.shift();
+        // also remove the output node.
+        route.splice(route.length - 1);
+        let value = await mediaObject.getData();
+        let valueMime = new whatwg_mimetype_1.default(mediaObject.mimeType);
+        while (route.length) {
+            const node = route.shift();
+            const converter = converterMap.get(node);
+            const converterToMimeType = new whatwg_mimetype_1.default(converter.toMimeType);
+            const converterFromMimeType = new whatwg_mimetype_1.default(converter.fromMimeType);
+            const type = converterToMimeType.type === '*' ? valueMime.type : converterToMimeType.type;
+            const subtype = converterToMimeType.subtype === '*' ? valueMime.subtype : converterToMimeType.subtype;
+            let targetMimeType = `${type}/${subtype}`;
+            if (!route.length && outputMime.parameters.size) {
+                const withParameters = new whatwg_mimetype_1.default(targetMimeType);
+                for (const k of outputMime.parameters.keys()) {
+                    withParameters.parameters.set(k, outputMime.parameters.get(k));
+                }
+                targetMimeType = outputMime.toString();
+            }
+            if (converter.toMimeType === types_1.ScryptedMimeTypes.MediaObject) {
+                const mo = await converter.convert(value, valueMime.essence, toMimeType, { sourceId });
+                const found = await this.convertMediaObject(mo, toMimeType);
+                return {
+                    data: found,
+                    mimeType: toMimeType,
+                };
+            }
+            value = await converter.convert(value, valueMime.essence, targetMimeType, { sourceId });
+            valueMime = new whatwg_mimetype_1.default(targetMimeType);
+        }
+        return {
+            data: value,
+            mimeType: valueMime.essence,
+        };
+    }
+}
+exports.MediaManagerBase = MediaManagerBase;
+class MediaManagerImpl extends MediaManagerBase {
+    systemManager;
+    deviceManager;
+    constructor(systemManager, deviceManager) {
+        super();
+        this.systemManager = systemManager;
+        this.deviceManager = deviceManager;
+    }
+    getSystemState() {
+        return this.systemManager.getSystemState();
+    }
+    getDeviceById(id) {
+        return this.systemManager.getDeviceById(id);
+    }
+    getPluginDeviceId() {
+        return this.deviceManager.getDeviceState().id;
+    }
+    getMixinConsole(mixinId, nativeId) {
+        if (typeof mixinId !== 'string')
+            return this.deviceManager.getDeviceConsole(nativeId);
+        return this.deviceManager.getMixinConsole(mixinId, nativeId);
+    }
+}
+exports.MediaManagerImpl = MediaManagerImpl;
+class MediaManagerHostImpl extends MediaManagerBase {
+    pluginDeviceId;
+    getSystemState;
+    console;
+    getDeviceById;
+    constructor(pluginDeviceId, getSystemState, console, getDeviceById) {
+        super();
+        this.pluginDeviceId = pluginDeviceId;
+        this.getSystemState = getSystemState;
+        this.console = console;
+        this.getDeviceById = getDeviceById;
+    }
+    getPluginDeviceId() {
+        return this.pluginDeviceId;
+    }
+    getMixinConsole(mixinId, nativeId) {
+        return this.console;
+    }
+}
+exports.MediaManagerHostImpl = MediaManagerHostImpl;
+//# sourceMappingURL=media.js.map