@scrypted/server 0.123.31 → 0.123.32

package/python/plugin_remote.py

@@ -18,7 +18,7 @@ from asyncio.streams import StreamReader, StreamWriter
 from collections.abc import Mapping
 from io import StringIO
 from typing import Any, Callable, Coroutine, Optional, Set, Tuple, TypedDict
-
+import plugin_console
 import plugin_volume as pv
 import rpc
 import rpc_reader
@@ -202,6 +202,21 @@ class EventRegistry(object):
 
         return True
 
+class ClusterManager(scrypted_python.scrypted_sdk.types.ClusterManager):
+    def __init__(self, api: Any):
+        self.api = api
+        self.clusterService = None
+
+    def getClusterMode(self) -> Any | Any:
+        return os.getenv("SCRYPTED_CLUSTER_MODE", None)
+
+    def getClusterWorkerId(self) -> str:
+        return os.getenv("SCRYPTED_CLUSTER_WORKER_ID", None)
+
+    async def getClusterWorkers(self) -> Mapping[str, scrypted_python.scrypted_sdk.types.ClusterWorker]:
+        self.clusterService = self.clusterService or asyncio.ensure_future(self.api.getComponent("cluster-fork"))
+        cs = await self.clusterService
+        return await cs.getClusterWorkers()
 
 class SystemManager(scrypted_python.scrypted_sdk.types.SystemManager):
     def __init__(
@@ -547,6 +562,12 @@ class PeerLiveness:
     async def waitKilled(self):
         await self.killed
 
+def safe_set_result(fut: Future, result: Any):
+    try:
+        fut.set_result(result)
+    except:
+        pass
+
 class PluginRemote:
     def __init__(
         self, clusterSetup: ClusterSetup, api, pluginId: str, hostInfo, loop: AbstractEventLoop
@@ -554,6 +575,7 @@ class PluginRemote:
         self.systemState: Mapping[str, Mapping[str, SystemDeviceState]] = {}
         self.nativeIds: Mapping[str, DeviceStorage] = {}
         self.mediaManager: MediaManager
+        self.clusterManager: ClusterManager
         self.consoles: Mapping[str, Future[Tuple[StreamReader, StreamWriter]]] = {}
         self.peer = clusterSetup.peer
         self.clusterSetup = clusterSetup
@@ -622,17 +644,17 @@ class PluginRemote:
             traceback.print_exc()
             raise
 
-    async def loadZipWrapped(self, packageJson, zipAPI: Any, options: dict):
-        await self.clusterSetup.initializeCluster(options)
+    async def loadZipWrapped(self, packageJson, zipAPI: Any, zipOptions: dict):
+        await self.clusterSetup.initializeCluster(zipOptions)
 
         sdk = ScryptedStatic()
 
         sdk.connectRPCObject = lambda v: self.clusterSetup.connectRPCObject(v)
 
-        forkMain = options and options.get("fork")
-        debug = options.get("debug", None)
+        forkMain = zipOptions and zipOptions.get("fork")
+        debug = zipOptions.get("debug", None)
         plugin_volume = pv.ensure_plugin_volume(self.pluginId)
-        zipHash = options.get("zipHash")
+        zipHash = zipOptions.get("zipHash")
         plugin_zip_paths = pv.prep(plugin_volume, zipHash)
 
         if debug:
@@ -660,6 +682,13 @@ class PluginRemote:
 
         if not forkMain:
             multiprocessing.set_start_method("spawn")
+        
+        # forkMain may be set to true, but the environment may not be initialized
+        # if the plugin is loaded in another cluster worker.
+        # instead rely on a environemnt variable that will be passed to
+        # child processes.
+        if not os.environ.get("SCRYPTED_PYTHON_INITIALIZED", None):
+            os.environ["SCRYPTED_PYTHON_INITIALIZED"] = "1"
 
             # it's possible to run 32bit docker on aarch64, which cause pip requirements
             # to fail because pip only allows filtering on machine, even if running a different architeture.
@@ -761,24 +790,44 @@ class PluginRemote:
         self.systemManager = SystemManager(self.api, self.systemState)
         self.deviceManager = DeviceManager(self.nativeIds, self.systemManager)
         self.mediaManager = MediaManager(await self.api.getMediaManager())
+        self.clusterManager = ClusterManager(self.api)
 
         try:
-            from scrypted_sdk import sdk_init2  # type: ignore
-
             sdk.systemManager = self.systemManager
             sdk.deviceManager = self.deviceManager
             sdk.mediaManager = self.mediaManager
+            sdk.clusterManager = self.clusterManager
             sdk.remote = self
             sdk.api = self.api
             sdk.zip = zip
 
             def host_fork(options: dict = None) -> PluginFork:
+                async def finishFork(forkPeer: rpc.RpcPeer):
+                    getRemote = await forkPeer.getParam("getRemote")
+                    remote: PluginRemote = await getRemote(
+                        self.api, self.pluginId, self.hostInfo
+                    )
+                    await remote.setSystemState(self.systemManager.getSystemState())
+                    for nativeId, ds in self.nativeIds.items():
+                        await remote.setNativeId(nativeId, ds.id, ds.storage)
+                    forkOptions = zipOptions.copy()
+                    forkOptions["fork"] = True
+                    forkOptions["debug"] = debug
+
+                    class PluginZipAPI:
+
+                        async def getZip(self):
+                            return await zipAPI.getZip()
+
+                    return await remote.loadZip(packageJson, PluginZipAPI(), forkOptions)
+
                 if cluster_labels.needs_cluster_fork_worker(options):
                     peerLiveness = PeerLiveness(self.loop)
-                    async def startClusterFork():
+                    async def getClusterFork():
                         forkComponent = await self.api.getComponent("cluster-fork")
                         sanitizedOptions = options.copy()
                         sanitizedOptions["runtime"] = sanitizedOptions.get("runtime", "python")
+                        sanitizedOptions["zipHash"] = zipHash
                         clusterForkResult = await forkComponent.fork(peerLiveness, sanitizedOptions, packageJson, zipHash, lambda: zipAPI.getZip())
                         
                         async def waitPeerLiveness():
@@ -791,20 +840,44 @@ class PluginRemote:
                                     pass
                         asyncio.ensure_future(waitPeerLiveness(), loop=self.loop)
 
-                        async def waitClusterForkResult():
+                        async def waitClusterForkKilled():
                             try:
                                 await clusterForkResult.waitKilled()
                             except:
                                 pass
-                            peerLiveness.killed.set_result(None)
-                        asyncio.ensure_future(waitClusterForkResult(), loop=self.loop)
+                            safe_set_result(peerLiveness.killed, None)
+                        asyncio.ensure_future(waitClusterForkKilled(), loop=self.loop)
+
+                        clusterGetRemote = await self.clusterSetup.connectRPCObject(await clusterForkResult.getResult())
+                        remoteDict = await clusterGetRemote()
+                        asyncio.ensure_future(plugin_console.writeWorkerGenerator(remoteDict["stdout"], sys.stdout))
+                        asyncio.ensure_future(plugin_console.writeWorkerGenerator(remoteDict["stderr"], sys.stderr))
+
+                        getRemote = remoteDict["getRemote"]
+                        directGetRemote = await self.clusterSetup.connectRPCObject(getRemote)
+                        if directGetRemote is getRemote:
+                            raise Exception("cluster fork peer not direct connected")
+
+                        forkPeer = getattr(directGetRemote, rpc.RpcPeer.PROPERTY_PROXY_PEER)
+                        return await finishFork(forkPeer)
+
 
-                    result = asyncio.ensure_future(startClusterFork(), loop=self.loop)
                     pluginFork = PluginFork()
-                    pluginFork.result = result
-                    pluginFork.terminate = lambda: peerLiveness.killed.set_result(None)
+                    pluginFork.result = asyncio.create_task(getClusterFork())
+                    async def waitKilled():
+                        await peerLiveness.killed
+                    pluginFork.exit = asyncio.create_task(waitKilled())
+                    def terminate():
+                        safe_set_result(peerLiveness.killed, None)
+                        pluginFork.worker.terminate()
+                    pluginFork.terminate = terminate
+
+                    pluginFork.worker = None
+
                     return pluginFork
 
+                t: asyncio.Task
+                t.cancel()
                 if options:
                     runtime = options.get("runtime", None)
                     if runtime and runtime != "python":
@@ -813,8 +886,17 @@ class PluginRemote:
                         raise Exception("python fork to filename not supported")
 
                 parent_conn, child_conn = multiprocessing.Pipe()
+
                 pluginFork = PluginFork()
-                print("new fork")
+                killed = Future(loop=self.loop)
+                async def waitKilled():
+                    await killed
+                pluginFork.exit = asyncio.create_task(waitKilled())
+                def terminate():
+                    safe_set_result(killed, None)
+                    pluginFork.worker.kill()
+                pluginFork.terminate = terminate
+
                 pluginFork.worker = multiprocessing.Process(
                     target=plugin_fork, args=(child_conn,), daemon=True
                 )
@@ -823,6 +905,7 @@ class PluginRemote:
                 def schedule_exit_check():
                     def exit_check():
                         if pluginFork.worker.exitcode != None:
+                            safe_set_result(killed, None)
                             pluginFork.worker.join()
                         else:
                             schedule_exit_check()
@@ -847,26 +930,11 @@ class PluginRemote:
                         finally:
                             parent_conn.close()
                             rpcTransport.executor.shutdown()
-                            pluginFork.worker.kill()
+                            pluginFork.terminate()
 
                     asyncio.run_coroutine_threadsafe(forkReadLoop(), loop=self.loop)
-                    getRemote = await forkPeer.getParam("getRemote")
-                    remote: PluginRemote = await getRemote(
-                        self.api, self.pluginId, self.hostInfo
-                    )
-                    await remote.setSystemState(self.systemManager.getSystemState())
-                    for nativeId, ds in self.nativeIds.items():
-                        await remote.setNativeId(nativeId, ds.id, ds.storage)
-                    forkOptions = options.copy()
-                    forkOptions["fork"] = True
-                    forkOptions["debug"] = debug
-
-                    class PluginZipAPI:
-
-                        async def getZip(self):
-                            return await zipAPI.getZip()
 
-                    return await remote.loadZip(packageJson, PluginZipAPI(), forkOptions)
+                    return await finishFork(forkPeer)
 
                 pluginFork.result = asyncio.create_task(getFork())
                 return pluginFork
@@ -874,6 +942,7 @@ class PluginRemote:
             sdk.fork = host_fork
             # sdk.
 
+            from scrypted_sdk import sdk_init2  # type: ignore
             sdk_init2(sdk)
         except:
             from scrypted_sdk import sdk_init  # type: ignore

package/python/rpc.py

@@ -62,7 +62,7 @@ class RpcProxy(object):
         self.__dict__['__proxy_id'] = entry['id']
         self.__dict__['__proxy_entry'] = entry
         self.__dict__['__proxy_constructor'] = proxyConstructorName
-        self.__dict__['__proxy_peer'] = peer
+        self.__dict__[RpcPeer.PROPERTY_PROXY_PEER] = peer
         self.__dict__[RpcPeer.PROPERTY_PROXY_PROPERTIES] = proxyProps
         self.__dict__['__proxy_oneway_methods'] = proxyOneWayMethods
 
@@ -105,17 +105,18 @@ class RpcProxy(object):
         return super().__setattr__(name, value)
 
     def __call__(self, *args, **kwargs):
-        return self.__dict__['__proxy_peer'].__apply__(self.__dict__['__proxy_id'], self.__dict__['__proxy_oneway_methods'], None, args)
+        return self.__dict__[RpcPeer.PROPERTY_PROXY_PEER].__apply__(self.__dict__['__proxy_id'], self.__dict__['__proxy_oneway_methods'], None, args)
 
 
     def __apply__(self, method: str, args: list):
-        return self.__dict__['__proxy_peer'].__apply__(self.__dict__['__proxy_id'], self.__dict__['__proxy_oneway_methods'], method, args)
+        return self.__dict__[RpcPeer.PROPERTY_PROXY_PEER].__apply__(self.__dict__['__proxy_id'], self.__dict__['__proxy_oneway_methods'], method, args)
 
 
 class RpcPeer:
     RPC_RESULT_ERROR_NAME = 'RPCResultError'
     PROPERTY_PROXY_PROPERTIES = '__proxy_props'
     PROPERTY_JSON_COPY_SERIALIZE_CHILDREN = '__json_copy_serialize_children'
+    PROPERTY_PROXY_PEER = '__proxy_peer'
 
     def __init__(self, send: Callable[[object, Callable[[Exception], None], Dict], None]) -> None:
         self.send = send
@@ -288,7 +289,7 @@ class RpcPeer:
             return ret
 
         __proxy_id = getattr(value, '__proxy_id', None)
-        __proxy_peer = getattr(value, '__proxy_peer', None)
+        __proxy_peer = getattr(value, RpcPeer.PROPERTY_PROXY_PEER, None)
         if __proxy_id and __proxy_peer == self:
             ret = {
                 '__local_proxy_id': __proxy_id,

package/src/plugin/device.ts

@@ -0,0 +1,261 @@
+import { Device, DeviceManager, DeviceManifest, DeviceState, Logger, ScryptedNativeId, WritableDeviceState } from '@scrypted/types';
+import { RpcPeer } from '../rpc';
+import { PluginAPI, PluginLogger } from './plugin-api';
+import { checkProperty } from './plugin-state-check';
+import { SystemManagerImpl } from './system';
+
+class DeviceLogger implements Logger {
+    nativeId: ScryptedNativeId;
+    api: PluginAPI;
+    logger: Promise<PluginLogger>;
+
+    constructor(api: PluginAPI, nativeId: ScryptedNativeId, public console: any) {
+        this.api = api;
+        this.nativeId = nativeId;
+    }
+
+    async ensureLogger(): Promise<PluginLogger> {
+        if (!this.logger)
+            this.logger = this.api.getLogger(this.nativeId);
+        return await this.logger;
+    }
+
+    async log(level: string, message: string) {
+        (await this.ensureLogger()).log(level, message);
+    }
+
+    a(msg: string): void {
+        this.log('a', msg);
+    }
+    async clear() {
+        (await this.ensureLogger()).clear();
+    }
+    async clearAlert(msg: string) {
+        (await this.ensureLogger()).clearAlert(msg);
+    }
+    async clearAlerts() {
+        (await this.ensureLogger()).clearAlerts();
+    }
+    d(msg: string): void {
+        this.log('d', msg);
+    }
+    e(msg: string): void {
+        this.log('e', msg);
+    }
+    i(msg: string): void {
+        this.log('i', msg);
+    }
+    v(msg: string): void {
+        this.log('v', msg);
+    }
+    w(msg: string): void {
+        this.log('w', msg);
+    }
+}
+
+export class DeviceStateProxyHandler implements ProxyHandler<any> {
+    constructor(public deviceManager: DeviceManagerImpl, public id: string,
+        public setState: (property: string, value: any) => Promise<void>) {
+    }
+
+    get?(target: any, p: PropertyKey, receiver: any) {
+        if (p === 'id')
+            return this.id;
+        if (p === RpcPeer.PROPERTY_PROXY_PROPERTIES)
+            return { id: this.id }
+        if (p === 'setState')
+            return this.setState;
+        return this.deviceManager.systemManager.state[this.id][p as string]?.value;
+    }
+
+    set?(target: any, p: PropertyKey, value: any, receiver: any) {
+        checkProperty(p.toString(), value);
+        this.deviceManager.systemManager.state[this.id][p as string] = {
+            value,
+        };
+        this.setState(p.toString(), value);
+        return true;
+    }
+}
+
+interface DeviceManagerDevice {
+    id: string;
+    storage: { [key: string]: any };
+}
+
+export class DeviceManagerImpl implements DeviceManager {
+    api: PluginAPI;
+    nativeIds = new Map<string, DeviceManagerDevice>();
+    deviceStorage = new Map<string, StorageImpl>();
+    mixinStorage = new Map<string, Map<string, StorageImpl>>();
+
+    constructor(public systemManager: SystemManagerImpl,
+        public getDeviceConsole: (nativeId?: ScryptedNativeId) => Console,
+        public getMixinConsole: (mixinId: string, nativeId?: ScryptedNativeId) => Console) {
+    }
+
+    async requestRestart() {
+        return this.api.requestRestart();
+    }
+
+    getDeviceLogger(nativeId?: ScryptedNativeId): Logger {
+        return new DeviceLogger(this.api, nativeId, this.getDeviceConsole?.(nativeId) || console);
+    }
+
+    getDeviceState(nativeId?: any): DeviceState {
+        const handler = new DeviceStateProxyHandler(this, this.nativeIds.get(nativeId).id,
+            (property, value) => this.api.setState(nativeId, property, value));
+        return new Proxy(handler, handler);
+    }
+
+    createDeviceState(id: string, setState: (property: string, value: any) => Promise<void>): WritableDeviceState {
+        const handler = new DeviceStateProxyHandler(this, id, setState);
+        return new Proxy(handler, handler);
+    }
+
+    getDeviceStorage(nativeId?: any): StorageImpl {
+        let ret = this.deviceStorage.get(nativeId);
+        if (!ret) {
+            ret = new StorageImpl(this, nativeId);
+            this.deviceStorage.set(nativeId, ret);
+        }
+        return ret;
+    }
+    getMixinStorage(id: string, nativeId?: ScryptedNativeId) {
+        let ms = this.mixinStorage.get(nativeId);
+        if (!ms) {
+            ms = new Map();
+            this.mixinStorage.set(nativeId, ms);
+        }
+        let ret = ms.get(id);
+        if (!ret) {
+            ret = new StorageImpl(this, nativeId, `mixin:${id}:`);
+            ms.set(id, ret);
+        }
+        return ret;
+    }
+    pruneMixinStorage() {
+        for (const nativeId of this.nativeIds.keys()) {
+            const storage = this.nativeIds.get(nativeId).storage;
+            for (const key of Object.keys(storage)) {
+                if (!key.startsWith('mixin:'))
+                    continue;
+                const [, id,] = key.split(':');
+                // there's no rush to persist this, it will happen automatically on the plugin
+                // persisting something at some point.
+                // the key itself is unreachable due to the device no longer existing.
+                if (id && !this.systemManager.state[id])
+                    delete storage[key];
+            }
+        }
+    }
+    async onMixinEvent(id: string, nativeId: ScryptedNativeId, eventInterface: string, eventData: any) {
+        return this.api.onMixinEvent(id, nativeId, eventInterface, eventData);
+    }
+    getNativeIds(): string[] {
+        return Array.from(this.nativeIds.keys());
+    }
+    async onDeviceDiscovered(device: Device) {
+        return this.api.onDeviceDiscovered(device);
+    }
+    async onDeviceRemoved(nativeId: string) {
+        return this.api.onDeviceRemoved(nativeId);
+    }
+    async onDeviceEvent(nativeId: any, eventInterface: any, eventData?: any) {
+        return this.api.onDeviceEvent(nativeId, eventInterface, eventData);
+    }
+    async onDevicesChanged(devices: DeviceManifest) {
+        return this.api.onDevicesChanged(devices);
+    }
+}
+
+
+function toStorageString(value: any) {
+    if (value === null)
+        return 'null';
+    if (value === undefined)
+        return 'undefined';
+
+    return value.toString();
+}
+
+export class StorageImpl implements Storage {
+    api: PluginAPI;
+    [name: string]: any;
+
+    private static allowedMethods = [
+        'length',
+        'clear',
+        'getItem',
+        'setItem',
+        'key',
+        'removeItem',
+    ];
+    private static indexedHandler: ProxyHandler<StorageImpl> = {
+        get(target, property) {
+            const keyString = property.toString();
+            if (StorageImpl.allowedMethods.includes(keyString)) {
+                const f = target[keyString];
+                if (keyString === 'length')
+                    return f;
+                return f.bind(target);
+            }
+            return target.getItem(toStorageString(property));
+        },
+        set(target, property, value): boolean {
+            target.setItem(toStorageString(property), value);
+            return true;
+        }
+    };
+
+    constructor(public deviceManager: DeviceManagerImpl, public nativeId: ScryptedNativeId, public prefix?: string) {
+        this.deviceManager = deviceManager;
+        this.api = deviceManager.api;
+        this.nativeId = nativeId;
+        if (!this.prefix)
+            this.prefix = '';
+
+        return new Proxy(this, StorageImpl.indexedHandler);
+    }
+
+    get storage(): { [key: string]: any } {
+        return this.deviceManager.nativeIds.get(this.nativeId).storage;
+    }
+
+    get length(): number {
+        return Object.keys(this.storage).filter(key => key.startsWith(this.prefix)).length;
+    }
+
+    clear(): void {
+        if (!this.prefix) {
+            this.deviceManager.nativeIds.get(this.nativeId).storage = {};
+        }
+        else {
+            const storage = this.storage;
+            Object.keys(this.storage).filter(key => key.startsWith(this.prefix)).forEach(key => delete storage[key]);
+        }
+        this.api.setStorage(this.nativeId, this.storage);
+    }
+
+    getItem(key: string): string {
+        return this.storage[this.prefix + key];
+    }
+    key(index: number): string {
+        if (!this.prefix) {
+            return Object.keys(this.storage)[index];
+        }
+        return Object.keys(this.storage).filter(key => key.startsWith(this.prefix))[index].substring(this.prefix.length);
+    }
+    removeItem(key: string): void {
+        delete this.storage[this.prefix + key];
+        this.api.setStorage(this.nativeId, this.storage);
+    }
+    setItem(key: string, value: string): void {
+        key = toStorageString(key);
+        value = toStorageString(value);
+        if (this.storage[this.prefix + key] === value)
+            return;
+        this.storage[this.prefix + key] = value;
+        this.api.setStorage(this.nativeId, this.storage);
+    }
+}

package/src/plugin/endpoint.ts

@@ -0,0 +1,109 @@
+import { EndpointAccessControlAllowOrigin, MediaManager, ScryptedMimeTypes, type EndpointManager, type ScryptedNativeId } from "@scrypted/types";
+import type { DeviceManagerImpl } from "./device";
+import type { PluginAPI } from "./plugin-api";
+
+export class EndpointManagerImpl implements EndpointManager {
+    deviceManager: DeviceManagerImpl;
+    api: PluginAPI;
+    pluginId: string;
+    mediaManager: MediaManager;
+
+    getEndpoint(nativeId?: ScryptedNativeId) {
+        if (!nativeId)
+            return this.pluginId;
+        const id = this.deviceManager.nativeIds.get(nativeId)?.id;
+        if (!id)
+            throw new Error('invalid nativeId ' + nativeId);
+        if (!nativeId)
+            return this.pluginId;
+        return id;
+    }
+
+    async getUrlSafeIp() {
+        // ipv6 addresses have colons and need to be bracketed for url safety
+        const ip: string = await this.api.getComponent('SCRYPTED_IP_ADDRESS')
+        return ip?.includes(':') ? `[${ip}]` : ip;
+    }
+
+    /**
+     * @deprecated
+     */
+    async getAuthenticatedPath(nativeId?: ScryptedNativeId): Promise<string> {
+        return this.getPath(nativeId);
+    }
+
+    /**
+     * @deprecated
+     */
+    async getInsecurePublicLocalEndpoint(nativeId?: ScryptedNativeId): Promise<string> {
+        return this.getLocalEndpoint(nativeId, {
+            insecure: true,
+            public: true,
+        })
+    }
+
+    /**
+     * @deprecated
+     */
+    async getPublicCloudEndpoint(nativeId?: ScryptedNativeId): Promise<string> {
+        return this.getCloudEndpoint(nativeId, {
+            public: true,
+        });
+    }
+
+    /**
+     * @deprecated
+     */
+    async getPublicLocalEndpoint(nativeId?: ScryptedNativeId): Promise<string> {
+        return this.getLocalEndpoint(nativeId, {
+            public: true,
+        })
+    }
+
+    /**
+     * @deprecated
+     */
+    async getPublicPushEndpoint(nativeId?: ScryptedNativeId): Promise<string> {
+        const mo = await this.mediaManager.createMediaObject(Buffer.from(this.getEndpoint(nativeId)), ScryptedMimeTypes.PushEndpoint);
+        return this.mediaManager.convertMediaObjectToUrl(mo, ScryptedMimeTypes.PushEndpoint);
+    }
+
+    async getPath(nativeId?: string, options?: { public?: boolean; }): Promise<string> {
+        return `/endpoint/${this.getEndpoint(nativeId)}/${options?.public ? 'public/' : ''}`
+    }
+
+    async getLocalEndpoint(nativeId?: string, options?: { public?: boolean; insecure?: boolean; }): Promise<string> {
+        const protocol = options?.insecure ? 'http' : 'https';
+        const port = await this.api.getComponent(options?.insecure ? 'SCRYPTED_INSECURE_PORT' : 'SCRYPTED_SECURE_PORT');
+        const path = await this.getPath(nativeId, options);
+        const url = `${protocol}://${await this.getUrlSafeIp()}:${port}${path}`;
+        return url;
+    }
+
+    async getCloudEndpoint(nativeId?: string, options?: { public?: boolean; }): Promise<string> {
+        const local = await this.getLocalEndpoint(nativeId, options);
+        const mo = await this.mediaManager.createMediaObject(Buffer.from(local), ScryptedMimeTypes.LocalUrl);
+        return this.mediaManager.convertMediaObjectToUrl(mo, ScryptedMimeTypes.LocalUrl);
+    }
+
+    async getCloudPushEndpoint(nativeId?: string): Promise<string> {
+        const mo = await this.mediaManager.createMediaObject(Buffer.from(this.getEndpoint(nativeId)), ScryptedMimeTypes.PushEndpoint);
+        return this.mediaManager.convertMediaObjectToUrl(mo, ScryptedMimeTypes.PushEndpoint);
+    }
+
+    async setLocalAddresses(addresses: string[]): Promise<void> {
+        const addressSettings = await this.api.getComponent('addresses');
+        return addressSettings.setLocalAddresses(addresses);
+    }
+
+    async getLocalAddresses(): Promise<string[]> {
+        const addressSettings = await this.api.getComponent('addresses');
+        return await addressSettings.getLocalAddresses() as string[];
+    }
+
+    async setAccessControlAllowOrigin(options: EndpointAccessControlAllowOrigin): Promise<void> {
+        const self = this;
+        const setAccessControlAllowOrigin = await this.deviceManager.systemManager.getComponent('setAccessControlAllowOrigin') as typeof self.setAccessControlAllowOrigin;
+        return setAccessControlAllowOrigin(options);
+    }
+}