@scrypted/server 0.7.93 → 0.7.95

package/dist/runtime.js

@@ -0,0 +1,815 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ScryptedRuntime = void 0;
+const types_1 = require("@scrypted/types");
+const adm_zip_1 = __importDefault(require("adm-zip"));
+const axios_1 = __importDefault(require("axios"));
+const io = __importStar(require("engine.io"));
+const events_1 = require("events");
+const path_1 = __importDefault(require("path"));
+const rimraf_1 = __importDefault(require("rimraf"));
+const semver_1 = __importDefault(require("semver"));
+const stream_1 = require("stream");
+const tar_1 = __importDefault(require("tar"));
+const url_1 = require("url");
+const ws_1 = require("ws");
+const db_types_1 = require("./db-types");
+const http_interfaces_1 = require("./http-interfaces");
+const infer_defaults_1 = require("./infer-defaults");
+const logger_1 = require("./logger");
+const mixin_cycle_1 = require("./mixin/mixin-cycle");
+const acl_1 = require("./plugin/acl");
+const plugin_device_1 = require("./plugin/plugin-device");
+const plugin_host_1 = require("./plugin/plugin-host");
+const plugin_http_1 = require("./plugin/plugin-http");
+const plugin_remote_websocket_1 = require("./plugin/plugin-remote-websocket");
+const plugin_volume_1 = require("./plugin/plugin-volume");
+const server_settings_1 = require("./server-settings");
+const addresses_1 = require("./services/addresses");
+const alerts_1 = require("./services/alerts");
+const cors_1 = require("./services/cors");
+const info_1 = require("./services/info");
+const plugin_1 = require("./services/plugin");
+const service_control_1 = require("./services/service-control");
+const users_1 = require("./services/users");
+const state_1 = require("./state");
+const crypto_1 = __importDefault(require("crypto"));
+const python_worker_1 = require("./plugin/runtime/python-worker");
+const node_fork_worker_1 = require("./plugin/runtime/node-fork-worker");
+const MIN_SCRYPTED_CORE_VERSION = 'v0.1.16';
+const PLUGIN_DEVICE_STATE_VERSION = 2;
+class ScryptedRuntime extends plugin_http_1.PluginHttp {
+    mainFilename;
+    clusterId = crypto_1.default.randomBytes(3).toString('hex');
+    clusterSecret = crypto_1.default.randomBytes(16).toString('hex');
+    datastore;
+    plugins = {};
+    pluginDevices = {};
+    devices = {};
+    stateManager = new state_1.ScryptedStateManager(this);
+    logger = new logger_1.Logger(this, '', 'Scrypted');
+    devicesLogger = this.logger.getLogger('device', 'Devices');
+    wss = new ws_1.Server({ noServer: true });
+    wsAtomic = 0;
+    shellio = new io.Server({
+        pingTimeout: 120000,
+        perMessageDeflate: true,
+        cors: (req, callback) => {
+            const header = this.getAccessControlAllowOrigin(req.headers);
+            callback(undefined, {
+                origin: header,
+                credentials: true,
+            });
+        },
+    });
+    pluginComponent = new plugin_1.PluginComponent(this);
+    servieControl = new service_control_1.ServiceControl(this);
+    alerts = new alerts_1.Alerts(this);
+    corsControl = new cors_1.CORSControl(this);
+    addressSettings = new addresses_1.AddressSettings(this);
+    usersService = new users_1.UsersService(this);
+    pluginHosts = new Map();
+    constructor(mainFilename, datastore, insecure, secure, app) {
+        super(app);
+        this.mainFilename = mainFilename;
+        this.datastore = datastore;
+        this.app = app;
+        // ensure that all the users are loaded from the db.
+        this.usersService.getAllUsers();
+        this.pluginHosts.set('python', (_, pluginId, options) => new python_worker_1.PythonRuntimeWorker(pluginId, options));
+        this.pluginHosts.set('node', (mainFilename, pluginId, options) => new node_fork_worker_1.NodeForkWorker(mainFilename, pluginId, options));
+        app.disable('x-powered-by');
+        this.addMiddleware();
+        app.all('/engine.io/shell', (req, res) => {
+            if (res.locals.aclId) {
+                res.writeHead(401);
+                res.end();
+                return;
+            }
+            this.shellHandler(req, res);
+        });
+        this.shellio.on('connection', connection => {
+            try {
+                const spawn = require('node-pty-prebuilt-multiarch').spawn;
+                const cp = spawn(process.env.SHELL, [], {});
+                cp.onData(data => connection.send(data));
+                connection.on('message', message => cp.write(message.toString()));
+                connection.on('close', () => cp.kill());
+            }
+            catch (e) {
+                connection.close();
+            }
+        });
+        insecure.on('upgrade', (req, socket, upgradeHead) => {
+            req.upgradeHead = upgradeHead;
+            app.handle(req, {
+                socket,
+                upgradeHead
+            });
+        });
+        secure.on('upgrade', (req, socket, upgradeHead) => {
+            req.upgradeHead = upgradeHead;
+            app.handle(req, {
+                socket,
+                upgradeHead
+            });
+        });
+        this.logger.on('log', (logEntry) => {
+            if (logEntry.level !== 'a')
+                return;
+            console.log('alert', logEntry);
+            const alert = new db_types_1.ScryptedAlert();
+            alert._id = (0, logger_1.makeAlertId)(logEntry.path, logEntry.message);
+            alert.message = logEntry.message;
+            alert.timestamp = logEntry.timestamp;
+            alert.path = logEntry.path;
+            alert.title = logEntry.title;
+            datastore.upsert(alert);
+            this.stateManager.notifyInterfaceEvent(null, 'Logger', logEntry);
+        });
+        // purge logs older than 2 hours every hour
+        setInterval(() => {
+            this.logger.purge(Date.now() - 48 * 60 * 60 * 1000);
+        }, 60 * 60 * 1000);
+    }
+    checkUpgrade(req, res, pluginData) {
+        // pluginData.pluginHost.io.
+        const { sid } = req.query;
+        const client = pluginData.pluginHost.io.clients[sid];
+        if (client) {
+            res.locals.username = 'existing-io-session';
+        }
+    }
+    addAccessControlHeaders(req, res) {
+        res.setHeader('Vary', 'Origin,Referer');
+        const header = this.getAccessControlAllowOrigin(req.headers);
+        if (header) {
+            res.setHeader('Access-Control-Allow-Origin', header);
+        }
+        res.setHeader("Access-Control-Allow-Credentials", "true");
+        res.setHeader('Access-Control-Allow-Private-Network', 'true');
+        res.setHeader('Access-Control-Allow-Methods', 'GET, POST, OPTIONS');
+        res.setHeader('Access-Control-Allow-Headers', 'Content-Type, Authorization, Content-Length, X-Requested-With, Access-Control-Request-Method');
+    }
+    getAccessControlAllowOrigin(headers) {
+        let { origin, referer } = headers;
+        if (!origin && referer) {
+            try {
+                const u = new url_1.URL(headers.referer);
+                origin = u.origin;
+            }
+            catch (e) {
+                return;
+            }
+        }
+        if (!origin)
+            return;
+        const servers = process.env.SCRYPTED_ACCESS_CONTROL_ALLOW_ORIGINS?.split(',') || [];
+        servers.push(...Object.values(this.corsControl.origins).flat());
+        if (!servers.includes(origin))
+            return;
+        return origin;
+    }
+    getDeviceLogger(device) {
+        return this.devicesLogger.getLogger(device._id, (0, state_1.getState)(device, types_1.ScryptedInterfaceProperty.name));
+    }
+    async getPluginForEndpoint(endpoint) {
+        let pluginHost = this.plugins[endpoint] ?? this.getPluginHostForDeviceId(endpoint);
+        if (endpoint === '@scrypted/core') {
+            // enforce a minimum version on @scrypted/core
+            if (!pluginHost || semver_1.default.lt(pluginHost.packageJson.version, MIN_SCRYPTED_CORE_VERSION)) {
+                try {
+                    pluginHost = await this.installNpm('@scrypted/core');
+                }
+                catch (e) {
+                    console.error('@scrypted/core auto install failed', e);
+                }
+            }
+        }
+        const pluginDevice = this.findPluginDevice(endpoint) ?? this.findPluginDeviceById(endpoint);
+        return {
+            pluginHost,
+            pluginDevice,
+        };
+    }
+    async shellHandler(req, res) {
+        const isUpgrade = (0, plugin_http_1.isConnectionUpgrade)(req.headers);
+        const end = (code, message) => {
+            if (isUpgrade) {
+                const socket = res.socket;
+                socket.write(`HTTP/1.1 ${code} ${message}\r\n` +
+                    '\r\n');
+                socket.destroy();
+            }
+            else {
+                res.status(code);
+                res.send(message);
+            }
+        };
+        if (!res.locals.username) {
+            end(401, 'Not Authorized');
+            return;
+        }
+        if (req.upgradeHead)
+            this.shellio.handleUpgrade(req, res.socket, req.upgradeHead);
+        else
+            this.shellio.handleRequest(req, res);
+    }
+    async getEndpointPluginData(req, endpoint, isUpgrade, isEngineIOEndpoint) {
+        const ret = await this.getPluginForEndpoint(endpoint);
+        if (req.url.indexOf('/engine.io/api') !== -1)
+            return ret;
+        const { pluginDevice } = ret;
+        // check if upgrade requests can be handled. must be websocket.
+        if (isUpgrade) {
+            if (!pluginDevice?.state.interfaces.value.includes(types_1.ScryptedInterface.EngineIOHandler)) {
+                return;
+            }
+        }
+        else {
+            if (!isEngineIOEndpoint && !pluginDevice?.state.interfaces.value.includes(types_1.ScryptedInterface.HttpRequestHandler)) {
+                return;
+            }
+        }
+        return ret;
+    }
+    async handleWebSocket(endpoint, httpRequest, ws, pluginData) {
+        const { pluginDevice } = pluginData;
+        const handler = this.getDevice(pluginDevice._id);
+        const id = 'ws-' + this.wsAtomic++;
+        const pluginHost = this.plugins[endpoint] ?? this.getPluginHostForDeviceId(endpoint);
+        if (!pluginHost) {
+            ws.close();
+            return;
+        }
+        pluginHost.ws[id] = ws;
+        ws.on('message', async (message) => {
+            try {
+                pluginHost.remote.ioEvent(id, 'message', message);
+            }
+            catch (e) {
+                ws.close();
+            }
+        });
+        ws.on('close', async (reason) => {
+            try {
+                pluginHost.remote.ioEvent(id, 'close');
+            }
+            catch (e) {
+            }
+            delete pluginHost.ws[id];
+        });
+        // @ts-expect-error
+        await handler.onConnection(httpRequest, new plugin_remote_websocket_1.WebSocketConnection(`ws://${id}`, {
+            send(message) {
+                ws.send(message);
+            },
+            close(message) {
+                ws.close();
+            },
+        }));
+    }
+    async getComponent(componentId) {
+        switch (componentId) {
+            case 'SCRYPTED_IP_ADDRESS':
+                return (0, server_settings_1.getIpAddress)();
+            case 'SCRYPTED_INSECURE_PORT':
+                return server_settings_1.SCRYPTED_INSECURE_PORT;
+            case 'SCRYPTED_SECURE_PORT':
+                return server_settings_1.SCRYPTED_SECURE_PORT;
+            case 'info':
+                return new info_1.Info();
+            case 'plugins':
+                return this.pluginComponent;
+            case 'service-control':
+                return this.servieControl;
+            case 'logger':
+                return this.logger;
+            case 'alerts':
+                return this.alerts;
+            case 'cors':
+                return this.corsControl;
+            case 'addresses':
+                return this.addressSettings;
+            case "users":
+                return this.usersService;
+        }
+    }
+    async getPackageJson(pluginId) {
+        let packageJson;
+        if (this.plugins[pluginId]) {
+            packageJson = this.plugins[pluginId].packageJson;
+        }
+        else {
+            const plugin = await this.datastore.tryGet(db_types_1.Plugin, pluginId);
+            packageJson = plugin.packageJson;
+        }
+        return packageJson;
+    }
+    async getAccessControls(username) {
+        if (!username)
+            return;
+        const user = await this.datastore.tryGet(db_types_1.ScryptedUser, username);
+        if (user?.aclId) {
+            const accessControl = this.getDevice(user.aclId);
+            const acls = await accessControl.getScryptedUserAccessControl();
+            if (!acls)
+                return;
+            return new acl_1.AccessControls(acls);
+        }
+    }
+    async handleEngineIOEndpoint(req, res, endpointRequest, pluginData) {
+        const { pluginHost, pluginDevice } = pluginData;
+        const { username } = res.locals;
+        let accessControls;
+        try {
+            accessControls = await this.getAccessControls(username);
+            if (accessControls?.shouldRejectMethod(pluginDevice._id, types_1.ScryptedInterfaceMethod.onConnection))
+                accessControls.deny();
+        }
+        catch (e) {
+            res.writeHead(401);
+            res.end();
+            return;
+        }
+        if (!pluginHost || !pluginDevice) {
+            console.error('plugin does not exist or is still starting up.');
+            res.writeHead(500);
+            res.end();
+            return;
+        }
+        req.scrypted = {
+            endpointRequest,
+            pluginDevice,
+            accessControls,
+        };
+        if (req.upgradeHead)
+            pluginHost.io.handleUpgrade(req, res.socket, req.upgradeHead);
+        else
+            pluginHost.io.handleRequest(req, res);
+    }
+    handleRequestEndpoint(req, res, endpointRequest, pluginData) {
+        const { pluginHost, pluginDevice } = pluginData;
+        const handler = this.getDevice(pluginDevice._id);
+        if (handler.interfaces.includes(types_1.ScryptedInterface.EngineIOHandler) && (0, plugin_http_1.isConnectionUpgrade)(req.headers) && req.headers.upgrade?.toLowerCase() === 'websocket') {
+            this.wss.handleUpgrade(req, req.socket, null, ws => {
+                console.log(ws);
+            });
+        }
+        const filesPath = path_1.default.join((0, plugin_volume_1.getPluginVolume)(pluginHost.pluginId), 'files');
+        handler.onRequest(endpointRequest, (0, http_interfaces_1.createResponseInterface)(res, pluginHost.unzippedPath, filesPath));
+    }
+    killPlugin(pluginId) {
+        const existing = this.plugins[pluginId];
+        if (existing) {
+            delete this.plugins[pluginId];
+            existing.kill();
+        }
+    }
+    // should this be async?
+    invalidatePluginDevice(id) {
+        const proxyPair = this.devices[id];
+        if (!proxyPair)
+            return;
+        proxyPair.handler.invalidate();
+        return proxyPair;
+    }
+    // should this be async?
+    rebuildPluginDeviceMixinTable(id) {
+        const proxyPair = this.devices[id];
+        if (!proxyPair)
+            return;
+        proxyPair.handler.rebuildMixinTable();
+        return proxyPair;
+    }
+    invalidateMixins(ids) {
+        const ret = new Set();
+        const remaining = [...ids];
+        // first pass:
+        // for every id, find anything it is acting on as a mixin, and clear out the entry.
+        while (remaining.length) {
+            const id = remaining.pop();
+            for (const device of Object.values(this.devices)) {
+                const foundIndex = device.handler?.mixinTable?.findIndex(mt => mt.mixinProviderId === id);
+                if (foundIndex === -1 || foundIndex === undefined)
+                    continue;
+                const did = device.handler.id;
+                if (!ret.has(did)) {
+                    // add this to the list of mixin providers that need to be rebuilt
+                    ret.add(did);
+                    remaining.push(did);
+                }
+                // if it is the last entry, that means it is the device itself.
+                // can this happen? i don't think it is possible. mixin provider id would be undefined.
+                if (foundIndex === device.handler.mixinTable.length - 1) {
+                    console.warn('attempt to invalidate mixin on actual device?');
+                    continue;
+                }
+                const removed = device.handler.mixinTable.splice(0, foundIndex + 1);
+                for (const entry of removed) {
+                    console.log('invalidating mixin', device.handler.id, entry.mixinProviderId);
+                    device.handler.invalidateEntry(entry);
+                }
+            }
+        }
+        // second pass:
+        // rebuild the mixin tables.
+        for (const id of ret) {
+            const device = this.devices[id];
+            device.handler.rebuildMixinTable();
+        }
+        return ret;
+    }
+    async installNpm(pkg, version, installedSet) {
+        if (!installedSet)
+            installedSet = new Set();
+        if (installedSet.has(pkg))
+            return;
+        installedSet.add(pkg);
+        const registry = (await (0, axios_1.default)(`https://registry.npmjs.org/${pkg}`)).data;
+        if (!version) {
+            version = registry['dist-tags'].latest;
+        }
+        console.log('installing package', pkg, version);
+        const tarball = (await (0, axios_1.default)(`${registry.versions[version].dist.tarball}`, {
+            responseType: 'arraybuffer'
+        })).data;
+        console.log('downloaded tarball', tarball?.length);
+        const parse = new tar_1.default.Parse();
+        const files = {};
+        parse.on('entry', async (entry) => {
+            console.log('parsing entry', entry.path);
+            const chunks = [];
+            entry.on('data', (data) => chunks.push(data));
+            entry.on('end', () => {
+                const buffer = Buffer.concat(chunks);
+                files[entry.path] = buffer;
+            });
+        });
+        const ret = (async () => {
+            await (0, events_1.once)(parse, 'end');
+            console.log('npm package files:', Object.keys(files).join(', '));
+            const packageJsonEntry = files['package/package.json'];
+            if (!packageJsonEntry)
+                throw new Error('package.json not found. are you behind a firewall?');
+            const packageJson = JSON.parse(packageJsonEntry.toString());
+            const pluginDependencies = packageJson.scrypted.pluginDependencies || [];
+            pluginDependencies.forEach(async (dep) => {
+                try {
+                    const depId = this.findPluginDevice(dep);
+                    if (depId)
+                        throw new Error('Plugin already installed.');
+                    await this.installNpm(dep);
+                }
+                catch (e) {
+                    console.log('Skipping', dep, ':', e.message);
+                }
+            });
+            const npmPackage = packageJson.name;
+            const plugin = await this.datastore.tryGet(db_types_1.Plugin, npmPackage) || new db_types_1.Plugin();
+            plugin._id = npmPackage;
+            plugin.packageJson = packageJson;
+            plugin.zip = files['package/dist/plugin.zip'].toString('base64');
+            await this.datastore.upsert(plugin);
+            return this.installPlugin(plugin);
+        })();
+        const pt = new stream_1.PassThrough();
+        pt.write(Buffer.from(tarball));
+        pt.push(null);
+        pt.pipe(parse);
+        return ret;
+    }
+    async installPlugin(plugin, pluginDebug) {
+        const device = Object.assign({}, plugin.packageJson.scrypted, {
+            info: {
+                manufacturer: plugin.packageJson.name,
+                version: plugin.packageJson.version,
+            }
+        });
+        try {
+            if (!device.interfaces.includes(types_1.ScryptedInterface.Readme)) {
+                const zipData = Buffer.from(plugin.zip, 'base64');
+                const adm = new adm_zip_1.default(zipData);
+                const entry = adm.getEntry('README.md');
+                if (entry) {
+                    device.interfaces = device.interfaces.slice();
+                    device.interfaces.push(types_1.ScryptedInterface.Readme);
+                }
+            }
+        }
+        catch (e) {
+        }
+        this.upsertDevice(plugin._id, device);
+        return this.runPlugin(plugin, pluginDebug);
+    }
+    setupPluginHostAutoRestart(pluginHost) {
+        pluginHost.worker.once('exit', () => {
+            if (pluginHost.killed)
+                return;
+            pluginHost.kill();
+            const timeout = 60000;
+            console.error(`plugin unexpectedly exited, restarting in ${timeout}ms`, pluginHost.pluginId);
+            setTimeout(async () => {
+                const existing = this.plugins[pluginHost.pluginId];
+                if (existing !== pluginHost) {
+                    console.log('scheduled plugin restart cancelled, plugin was restarted by user', pluginHost.pluginId);
+                    return;
+                }
+                const plugin = await this.datastore.tryGet(db_types_1.Plugin, pluginHost.pluginId);
+                if (!plugin) {
+                    console.log('scheduled plugin restart cancelled, plugin no longer exists', pluginHost.pluginId);
+                    return;
+                }
+                try {
+                    this.runPlugin(plugin);
+                }
+                catch (e) {
+                    console.error('error restarting plugin', plugin._id, e);
+                }
+            }, timeout);
+        });
+    }
+    loadPlugin(plugin, pluginDebug) {
+        const pluginId = plugin._id;
+        this.killPlugin(pluginId);
+        const pluginDevices = this.findPluginDevices(pluginId);
+        for (const pluginDevice of pluginDevices) {
+            this.invalidatePluginDevice(pluginDevice._id);
+        }
+        const pluginHost = new plugin_host_1.PluginHost(this, plugin, pluginDebug);
+        this.setupPluginHostAutoRestart(pluginHost);
+        this.plugins[pluginId] = pluginHost;
+        return pluginHost;
+    }
+    probePluginDevices(plugin) {
+        const pluginId = plugin._id;
+        const pluginDevices = this.findPluginDevices(pluginId);
+        const pluginDeviceSet = new Set();
+        for (const pluginDevice of pluginDevices) {
+            if (pluginDeviceSet.has(pluginDevice._id))
+                continue;
+            pluginDeviceSet.add(pluginDevice._id);
+            this.getDevice(pluginDevice._id)?.probe().catch(() => { });
+        }
+        for (const pluginDevice of Object.values(this.pluginDevices)) {
+            const { _id } = pluginDevice;
+            if (pluginDeviceSet.has(_id))
+                continue;
+            for (const mixinId of (0, mixin_cycle_1.getMixins)(this, _id)) {
+                if (pluginDeviceSet.has(mixinId)) {
+                    this.getDevice(_id)?.probe().catch(() => { });
+                }
+            }
+        }
+    }
+    runPlugin(plugin, pluginDebug) {
+        const pluginHost = this.loadPlugin(plugin, pluginDebug);
+        this.probePluginDevices(plugin);
+        return pluginHost;
+    }
+    findPluginDevice(pluginId, nativeId) {
+        // JSON stringify over rpc turns undefined into null.
+        if (nativeId === null)
+            nativeId = undefined;
+        return Object.values(this.pluginDevices).find(device => device.pluginId === pluginId && device.nativeId == nativeId);
+    }
+    findPluginDeviceById(id) {
+        return this.pluginDevices[id];
+    }
+    findPluginDevices(pluginId) {
+        return Object.values(this.pluginDevices).filter(e => e.state && e.pluginId === pluginId);
+    }
+    getPluginHostForDeviceId(id) {
+        const device = this.pluginDevices[id];
+        if (!device)
+            return;
+        return this.plugins[device.pluginId];
+    }
+    getDevice(id) {
+        const device = this.devices[id];
+        if (device)
+            return device.proxy;
+        if (!this.pluginDevices[id]) {
+            console.warn('device not found', id);
+            return;
+        }
+        const handler = new plugin_device_1.PluginDeviceProxyHandler(this, id);
+        const proxy = new Proxy(handler, handler);
+        this.devices[id] = {
+            proxy,
+            handler,
+        };
+        return proxy;
+    }
+    async removeDevice(device) {
+        // delete any devices provided by this device
+        const providedDevices = Object.values(this.pluginDevices).filter(pluginDevice => (0, state_1.getState)(pluginDevice, types_1.ScryptedInterfaceProperty.providerId) === device._id);
+        for (const provided of providedDevices) {
+            if (provided === device)
+                continue;
+            await this.removeDevice(provided);
+        }
+        const providerId = device.state?.providerId?.value;
+        device.state = undefined;
+        this.invalidatePluginDevice(device._id);
+        delete this.pluginDevices[device._id];
+        await this.datastore.remove(device);
+        this.stateManager.removeDevice(device._id);
+        // if this device is acting as a mixin on anything, can now remove invalidate it.
+        // when the mixin table is rebuilt, it will be automatically ignore and remove the dangling mixin.
+        this.invalidateMixins(new Set([device._id]));
+        // if the device is a plugin, kill and remove the plugin as well.
+        if (!device.nativeId) {
+            this.killPlugin(device.pluginId);
+            await this.datastore.removeId(db_types_1.Plugin, device.pluginId);
+            rimraf_1.default.sync((0, plugin_volume_1.getPluginVolume)(device.pluginId));
+        }
+        else {
+            try {
+                // notify the plugin that a device was removed.
+                const plugin = this.plugins[device.pluginId];
+                await plugin.remote.setNativeId(device.nativeId, undefined, undefined);
+                const provider = this.getDevice(providerId);
+                await provider?.releaseDevice(device._id, device.nativeId);
+            }
+            catch (e) {
+                // may throw if the plugin is killed, etc.
+                console.warn('error while reporting device removal to plugin remote', e);
+            }
+        }
+    }
+    upsertDevice(pluginId, device) {
+        // JSON stringify over rpc turns undefined into null.
+        if (device.nativeId === null)
+            device.nativeId = undefined;
+        let pluginDevice = this.findPluginDevice(pluginId, device.nativeId);
+        if (!pluginDevice) {
+            pluginDevice = new db_types_1.PluginDevice(this.datastore.nextId().toString());
+            pluginDevice.stateVersion = PLUGIN_DEVICE_STATE_VERSION;
+        }
+        this.pluginDevices[pluginDevice._id] = pluginDevice;
+        pluginDevice.pluginId = pluginId;
+        pluginDevice.nativeId = device.nativeId;
+        pluginDevice.state = pluginDevice.state || {};
+        if (pluginDevice.state[types_1.ScryptedInterfaceProperty.nativeId]?.value !== pluginDevice.nativeId) {
+            (0, state_1.setState)(pluginDevice, types_1.ScryptedInterfaceProperty.nativeId, pluginDevice.nativeId);
+        }
+        const providedType = device.type;
+        const isUsingDefaultType = (0, infer_defaults_1.getDisplayType)(pluginDevice) === (0, infer_defaults_1.getProvidedTypeOrDefault)(pluginDevice);
+        const providedName = device.name;
+        const isUsingDefaultName = (0, infer_defaults_1.getDisplayName)(pluginDevice) === (0, infer_defaults_1.getProvidedNameOrDefault)(pluginDevice);
+        const providedRoom = device.room;
+        const isUsingDefaultRoom = (0, infer_defaults_1.getDisplayRoom)(pluginDevice) === (0, infer_defaults_1.getProvidedRoomOrDefault)(pluginDevice);
+        let providedInterfaces = device.interfaces.slice();
+        if (!device.nativeId)
+            providedInterfaces.push(types_1.ScryptedInterface.ScryptedPlugin);
+        else
+            providedInterfaces = providedInterfaces.filter(iface => iface !== types_1.ScryptedInterface.ScryptedPlugin);
+        providedInterfaces = plugin_device_1.PluginDeviceProxyHandler.sortInterfaces(providedInterfaces);
+        // assure final mixin resolved interface list has at least all the
+        // interfaces from the provided. the actual list will resolve lazily.
+        let mixinInterfaces = [];
+        const mixins = (0, state_1.getState)(pluginDevice, types_1.ScryptedInterfaceProperty.mixins) || [];
+        if (mixins.length)
+            mixinInterfaces.push(...(0, state_1.getState)(pluginDevice, types_1.ScryptedInterfaceProperty.interfaces) || []);
+        mixinInterfaces.push(...providedInterfaces.slice());
+        mixinInterfaces = plugin_device_1.PluginDeviceProxyHandler.sortInterfaces(mixinInterfaces);
+        this.stateManager.setPluginDeviceState(pluginDevice, types_1.ScryptedInterfaceProperty.pluginId, pluginId);
+        let interfacesChanged = this.stateManager.setPluginDeviceState(pluginDevice, types_1.ScryptedInterfaceProperty.providedInterfaces, providedInterfaces);
+        interfacesChanged = this.stateManager.setPluginDeviceState(pluginDevice, types_1.ScryptedInterfaceProperty.interfaces, mixinInterfaces)
+            || interfacesChanged;
+        if (device.info !== undefined)
+            this.stateManager.setPluginDeviceState(pluginDevice, types_1.ScryptedInterfaceProperty.info, device.info);
+        const provider = this.findPluginDevice(pluginId, device.providerNativeId);
+        this.stateManager.setPluginDeviceState(pluginDevice, types_1.ScryptedInterfaceProperty.providerId, provider?._id);
+        this.stateManager.setPluginDeviceState(pluginDevice, types_1.ScryptedInterfaceProperty.providedName, providedName);
+        this.stateManager.setPluginDeviceState(pluginDevice, types_1.ScryptedInterfaceProperty.providedType, providedType);
+        if (isUsingDefaultType)
+            this.stateManager.setPluginDeviceState(pluginDevice, types_1.ScryptedInterfaceProperty.type, (0, infer_defaults_1.getProvidedTypeOrDefault)(pluginDevice));
+        if (isUsingDefaultName)
+            this.stateManager.setPluginDeviceState(pluginDevice, types_1.ScryptedInterfaceProperty.name, (0, infer_defaults_1.getProvidedNameOrDefault)(pluginDevice));
+        this.stateManager.setPluginDeviceState(pluginDevice, types_1.ScryptedInterfaceProperty.providedRoom, providedRoom);
+        if (isUsingDefaultRoom)
+            this.stateManager.setPluginDeviceState(pluginDevice, types_1.ScryptedInterfaceProperty.room, (0, infer_defaults_1.getProvidedRoomOrDefault)(pluginDevice));
+        const ret = this.notifyPluginDeviceDescriptorChanged(pluginDevice);
+        return {
+            pluginDevicePromise: ret,
+            interfacesChanged,
+        };
+    }
+    notifyPluginDeviceDescriptorChanged(pluginDevice) {
+        const ret = this.datastore.upsert(pluginDevice);
+        // the descriptor events should happen after everything is set, as it's an atomic operation.
+        this.stateManager.updateDescriptor(pluginDevice);
+        this.stateManager.notifyInterfaceEvent(pluginDevice, types_1.ScryptedInterface.ScryptedDevice, undefined);
+        return ret;
+    }
+    killall() {
+        for (const host of Object.values(this.plugins)) {
+            host?.kill();
+        }
+        process.exit();
+    }
+    async start() {
+        // catch ctrl-c
+        process.on('SIGINT', () => this.killall());
+        // catch kill
+        process.on('SIGTERM', () => this.killall());
+        for await (const pluginDevice of this.datastore.getAll(db_types_1.PluginDevice)) {
+            // this may happen due to race condition around deletion/update. investigate.
+            if (!pluginDevice.state) {
+                this.datastore.remove(pluginDevice);
+                continue;
+            }
+            this.pluginDevices[pluginDevice._id] = pluginDevice;
+            let mixins = (0, state_1.getState)(pluginDevice, types_1.ScryptedInterfaceProperty.mixins) || [];
+            let dirty = false;
+            if (mixins.includes(null) || mixins.includes(undefined)) {
+                dirty = true;
+                (0, state_1.setState)(pluginDevice, types_1.ScryptedInterfaceProperty.mixins, mixins.filter(e => !!e));
+            }
+            const interfaces = (0, state_1.getState)(pluginDevice, types_1.ScryptedInterfaceProperty.providedInterfaces);
+            if (!pluginDevice.nativeId && !interfaces.includes(types_1.ScryptedInterface.ScryptedPlugin)) {
+                dirty = true;
+                interfaces.push(types_1.ScryptedInterface.ScryptedPlugin);
+                (0, state_1.setState)(pluginDevice, types_1.ScryptedInterfaceProperty.providedInterfaces, plugin_device_1.PluginDeviceProxyHandler.sortInterfaces(interfaces));
+            }
+            const pluginId = (0, state_1.getState)(pluginDevice, types_1.ScryptedInterfaceProperty.pluginId);
+            if (!pluginId) {
+                dirty = true;
+                (0, state_1.setState)(pluginDevice, types_1.ScryptedInterfaceProperty.pluginId, pluginDevice.pluginId);
+            }
+            if (pluginDevice.state[types_1.ScryptedInterfaceProperty.nativeId]?.value !== pluginDevice.nativeId) {
+                dirty = true;
+                (0, state_1.setState)(pluginDevice, types_1.ScryptedInterfaceProperty.nativeId, pluginDevice.nativeId);
+            }
+            if (dirty) {
+                this.datastore.upsert(pluginDevice)
+                    .catch(e => {
+                    console.error('There was an error saving the device? Ignoring...', e);
+                    // return this.datastore.remove(pluginDevice);
+                });
+            }
+        }
+        for (const id of Object.keys(this.stateManager.getSystemState())) {
+            if ((0, mixin_cycle_1.hasMixinCycle)(this, id)) {
+                console.warn(`initialize: ${id} has a mixin cycle. Clearing mixins.`);
+                const pluginDevice = this.findPluginDeviceById(id);
+                (0, state_1.setState)(pluginDevice, types_1.ScryptedInterfaceProperty.mixins, []);
+            }
+        }
+        const plugins = [];
+        for await (const plugin of this.datastore.getAll(db_types_1.Plugin)) {
+            plugins.push(plugin);
+        }
+        for (const plugin of plugins) {
+            try {
+                const pluginDevice = this.findPluginDevice(plugin._id);
+                (0, state_1.setState)(pluginDevice, types_1.ScryptedInterfaceProperty.info, {
+                    manufacturer: plugin.packageJson.name,
+                    version: plugin.packageJson.version,
+                });
+                this.loadPlugin(plugin);
+            }
+            catch (e) {
+                console.error('error loading plugin', plugin._id, e);
+            }
+        }
+        for (const plugin of plugins) {
+            try {
+                this.probePluginDevices(plugin);
+            }
+            catch (e) {
+                console.error('error probing plugin devices', plugin._id, e);
+            }
+        }
+    }
+}
+exports.ScryptedRuntime = ScryptedRuntime;
+//# sourceMappingURL=runtime.js.map