@scrypted/server 0.7.22 → 0.7.24

package/dist/services/plugin.d.ts

@@ -0,0 +1,46 @@
+/// <reference types="node" />
+import { ScryptedNativeId } from "@scrypted/types";
+import { ScryptedRuntime } from "../runtime";
+export declare class PluginComponent {
+    scrypted: ScryptedRuntime;
+    constructor(scrypted: ScryptedRuntime);
+    renameDeviceId(id: string, newId: string): Promise<void>;
+    getStorage(id: string): {
+        [key: string]: string;
+    };
+    setStorage(id: string, storage: {
+        [key: string]: string;
+    }): Promise<void>;
+    setMixins(id: string, mixins: string[]): Promise<void>;
+    getIdForPluginId(pluginId: string): Promise<string>;
+    getIdForNativeId(pluginId: string, nativeId: ScryptedNativeId): Promise<string>;
+    reload(pluginId: string): Promise<void>;
+    kill(pluginId: string): Promise<void>;
+    getPackageJson(pluginId: string): Promise<any>;
+    getDeviceInfo(id: string): Promise<{
+        mixins: any;
+        pluginId: string;
+        storage: {
+            [key: string]: string;
+        };
+        nativeId: string;
+    }>;
+    getPluginInfo(pluginId: string): Promise<{
+        pid: number;
+        stats: {
+            cpuUsage: NodeJS.CpuUsage;
+            memoryUsage: NodeJS.MemoryUsage;
+        };
+        rpcObjects: number;
+        packageJson: any;
+        pendingResults: number;
+        id: string;
+    }>;
+    installNpm(pkg: string, version?: string): Promise<void>;
+    npmInfo(endpoint: string): Promise<any>;
+    updatePlugins(): Promise<void>;
+    clearConsole(id: string): Promise<void>;
+    getRemoteServicePort(pluginId: string, name: string, ...args: any[]): Promise<number>;
+    setHostParam(pluginId: string, name: string, param?: any): Promise<void>;
+    getHostParam(pluginId: string, name: string): Promise<any>;
+}

package/dist/services/service-control.d.ts

@@ -0,0 +1,8 @@
+import { ScryptedRuntime } from "../runtime";
+export declare class ServiceControl {
+    scrypted: ScryptedRuntime;
+    constructor(scrypted: ScryptedRuntime);
+    exit(): Promise<void>;
+    restart(): Promise<void>;
+    update(): Promise<any>;
+}

package/dist/services/users.d.ts

@@ -0,0 +1,14 @@
+import { ScryptedUser } from "../db-types";
+import { ScryptedRuntime } from "../runtime";
+export declare class UsersService {
+    scrypted: ScryptedRuntime;
+    constructor(scrypted: ScryptedRuntime);
+    getAllUsers(): Promise<{
+        username: string;
+        admin: boolean;
+    }[]>;
+    removeUser(username: string): Promise<void>;
+    removeAllUsers(): Promise<void>;
+    addUser(username: string, password: string, aclId: string): Promise<void>;
+}
+export declare function setScryptedUserPassword(user: ScryptedUser, password: string, timestamp: number): void;

package/dist/sleep.d.ts

@@ -0,0 +1 @@
+export declare function sleep(ms: number): Promise<void>;

package/dist/state.d.ts

@@ -0,0 +1,39 @@
+/// <reference types="lodash" />
+import { EventDetails, EventListenerOptions, EventListenerRegister, ScryptedInterface, SystemDeviceState } from "@scrypted/types";
+import { PluginDevice } from "./db-types";
+import { EventRegistry } from "./event-registry";
+import { ScryptedRuntime } from "./runtime";
+export declare class ScryptedStateManager extends EventRegistry {
+    scrypted: ScryptedRuntime;
+    upserts: Set<string>;
+    upsertThrottle: import("lodash").DebouncedFunc<() => void>;
+    constructor(scrypted: ScryptedRuntime);
+    getImplementerId(pluginDevice: PluginDevice, eventInterface: ScryptedInterface | string): Promise<string>;
+    notifyInterfaceEventFromMixin(pluginDevice: PluginDevice, eventInterface: ScryptedInterface | string, value: any, mixinId: string): Promise<void>;
+    setPluginDeviceStateFromMixin(pluginDevice: PluginDevice, property: string, value: any, eventInterface: ScryptedInterface, mixinId: string): Promise<boolean>;
+    setPluginDeviceState(device: PluginDevice, property: string, value: any, eventInterface?: ScryptedInterface): boolean;
+    updateDescriptor(device: PluginDevice): void;
+    removeDevice(id: string): void;
+    notifyInterfaceEvent(device: PluginDevice, eventInterface: ScryptedInterface | string, value: any, mixinId?: string): void;
+    setState(id: string, property: string, value: any): boolean;
+    getSystemState(): {
+        [id: string]: {
+            [property: string]: SystemDeviceState;
+        };
+    };
+    listenDevice(id: string, options: string | EventListenerOptions, callback: (eventDetails: EventDetails, eventData: any) => void): EventListenerRegister;
+    refreshThrottles: {
+        [id: string]: RefreshThrottle;
+    };
+    getOrCreateRefreshThrottle(id: string, refreshInterface: string, userInitiated: boolean): RefreshThrottle;
+    refresh(id: string, refreshInterface: string, userInitiated: boolean): Promise<void>;
+}
+interface RefreshThrottle {
+    promise: Promise<void>;
+    refreshInterface: string;
+    userInitiated: boolean;
+    tailRefresh: boolean;
+}
+export declare function setState(pluginDevice: PluginDevice, property: string, value: any): boolean;
+export declare function getState(pluginDevice: PluginDevice, property: string): any;
+export {};

package/dist/threading.d.ts

@@ -0,0 +1,3 @@
+export declare function newThread<T>(thread: () => Promise<T>): Promise<T>;
+export declare function newThread<V, T>(params: V, thread: (params: V) => Promise<T>): Promise<T>;
+export declare function newThread<M, V, T>(modules: M, params: V, thread: (params: M & V) => Promise<T>): Promise<T>;

package/dist/usertoken.d.ts

@@ -0,0 +1,11 @@
+export declare const ONE_DAY_MILLISECONDS = 86400000;
+export declare const ONE_YEAR_MILLISECONDS: number;
+export declare class UserToken {
+    username: string;
+    aclId: string;
+    timestamp: number;
+    duration: number;
+    constructor(username: string, aclId: string, timestamp?: number, duration?: number);
+    static validateToken(token: string): UserToken;
+    toString(): string;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@scrypted/server",
-  "version": "0.7.22",
+  "version": "0.7.24",
   "description": "",
   "dependencies": {
     "@mapbox/node-pre-gyp": "^1.0.10",
@@ -61,6 +61,7 @@
     "scrypted-serve": "bin/scrypted-serve"
   },
   "main": "dist/scrypted-main-exports.js",
+  "types": "dist/scrypted-main-exports.d.ts",
   "scripts": {
     "preserve": "npm run build",
     "serve": "node --expose-gc dist/scrypted-main.js",

package/python/rpc-iterator-test.py

@@ -1,13 +1,13 @@
 import asyncio
 import rpc
-from  rpc_reader import prepare_peer_readloop
+from  rpc_reader import prepare_peer_readloop, RpcFileTransport
 import traceback
 
 class Bar:
     pass
 
 async def main():
-    peer, peerReadLoop = await prepare_peer_readloop(loop, 4, 3)
+    peer, peerReadLoop = await prepare_peer_readloop(loop, RpcFileTransport(4, 3))
     peer.params['foo'] = 3
     jsoncopy = {}
     jsoncopy[rpc.RpcPeer.PROPERTY_JSON_COPY_SERIALIZE_CHILDREN] = True
@@ -35,8 +35,12 @@ async def main():
     test = await peer.getParam('test')
     print(test)
     try:
-        async for c in test:
+        i = 0
+        async for c in await test():
             print(c)
+            if i == 5:
+                break
+            i = i + 1
     except:
         traceback.print_exc()
     print('all done iterating')

package/python/rpc.py

@@ -79,6 +79,14 @@ class RpcProxy(object):
                 raise
         raise Exception('RpcProxy is not an async iterable')
 
+    async def aclose(self):
+        if self.__dict__[RpcPeer.PROPERTY_PROXY_PROPERTIES] and 'Symbol(Symbol.asyncIterator)' in self.__dict__[RpcPeer.PROPERTY_PROXY_PROPERTIES]:
+            try:
+                return await RpcProxyMethod(self, self.__dict__[RpcPeer.PROPERTY_PROXY_PROPERTIES]['Symbol(Symbol.asyncIterator)']['return'])()
+            except RPCResultError as e:
+                pass
+        raise Exception('RpcProxy is not an async iterable')
+
     def __getattr__(self, name):
         if name == '__proxy_finalizer_id':
             return self.dict['__proxy_entry']['finalizerId']

package/src/plugin/plugin-host.ts

@@ -26,9 +26,6 @@ import { LazyRemote } from './plugin-lazy-remote';
 import { setupPluginRemote } from './plugin-remote';
 import { WebSocketConnection } from './plugin-remote-websocket';
 import { ensurePluginVolume, getScryptedVolume } from './plugin-volume';
-import { NodeForkWorker } from './runtime/node-fork-worker';
-import { NodeThreadWorker } from './runtime/node-thread-worker';
-import { PythonRuntimeWorker } from './runtime/python-worker';
 import { RuntimeWorker } from './runtime/runtime-worker';
 
 const serverVersion = require('../../package.json').version;
@@ -288,29 +285,17 @@ export class PluginHost {
     startPluginHost(logger: Logger, env: any, pluginDebug: PluginDebug) {
         let connected = true;
 
-        if (this.packageJson.scrypted.runtime === 'python') {
-            this.worker = new PythonRuntimeWorker(this.pluginId, {
-                env,
-                pluginDebug,
-            });
-        }
-        else if (!this.packageJson.scrypted.runtime || this.packageJson.scrypted.runtime === 'node') {
-            if (!process.env.SCRYPTED_SHARED_WORKER || (this.packageJson.optionalDependencies && Object.keys(this.packageJson.optionalDependencies).length)) {
-                this.worker = new NodeForkWorker(this.scrypted.mainFilename, this.pluginId, {
-                    env,
-                    pluginDebug,
-                });
-            }
-            else {
-                this.worker = new NodeThreadWorker(this.scrypted.mainFilename, this.pluginId, {
-                    env,
-                    pluginDebug,
-                });
-            }
-        }
-        else {
+        let { runtime } = this.packageJson.scrypted;
+        runtime ||= 'node';
+
+        const workerHost = this.scrypted.pluginHosts.get(runtime);
+        if (!workerHost)
             throw new Error(`Unsupported Scrypted runtime: ${this.packageJson.scrypted.runtime}`);
-        }
+
+        this.worker = workerHost(this.scrypted.mainFilename, this.pluginId, {
+            env,
+            pluginDebug,
+        });
 
         this.peer = new RpcPeer('host', this.pluginId, (message, reject, serializationContext) => {
             if (connected) {

package/src/plugin/plugin-remote-worker.ts

@@ -191,10 +191,10 @@ export function startPluginRemote(mainFilename: string, pluginId: string, peerSe
                 const module = require(name);
                 return module;
             };
-            const window: any = {};
-            const exports: any = window;
-            window.exports = exports;
-            params.window = window;
+            // const window: any = {};
+            const exports: any = {};
+            // window.exports = exports;
+            // params.window = window;
             params.exports = exports;
 
             const entry = pluginReader('main.nodejs.js.map')

package/src/plugin/runtime/node-fork-worker.ts

@@ -11,9 +11,9 @@ export class NodeForkWorker extends ChildProcessWorker {
 
     constructor(mainFilename: string, pluginId: string, options: RuntimeWorkerOptions) {
         super(pluginId, options);
-        
-        const {env, pluginDebug} = options;
-        
+
+        const { env, pluginDebug } = options;
+
         const execArgv: string[] = process.execArgv.slice();
         if (pluginDebug) {
             execArgv.push(`--inspect=0.0.0.0:${pluginDebug.inspectPort}`);

package/src/plugin/runtime/runtime-worker.ts

@@ -1,6 +1,6 @@
 import { RpcMessage, RpcPeer } from "../../rpc";
 import { PluginDebug } from "../plugin-debug";
-import {Readable} from "stream";
+import { Readable } from "stream";
 import net from "net";
 
 export interface RuntimeWorkerOptions {

package/src/runtime.ts

@@ -40,6 +40,9 @@ import { ServiceControl } from './services/service-control';
 import { UsersService } from './services/users';
 import { getState, ScryptedStateManager, setState } from './state';
 import crypto from 'crypto';
+import { RuntimeWorker, RuntimeWorkerOptions } from './plugin/runtime/runtime-worker';
+import { PythonRuntimeWorker } from './plugin/runtime/python-worker';
+import { NodeForkWorker } from './plugin/runtime/node-fork-worker';
 
 interface DeviceProxyPair {
     handler: PluginDeviceProxyHandler;
@@ -54,6 +57,8 @@ interface HttpPluginData {
     pluginDevice: PluginDevice
 }
 
+export type RuntimeHost = (mainFilename: string, pluginId: string, options: RuntimeWorkerOptions) => RuntimeWorker;
+
 export class ScryptedRuntime extends PluginHttp<HttpPluginData> {
     clusterId = crypto.randomBytes(3).toString('hex');
     clusterSecret = crypto.randomBytes(16).toString('hex');
@@ -83,12 +88,16 @@ export class ScryptedRuntime extends PluginHttp<HttpPluginData> {
     corsControl = new CORSControl(this);
     addressSettings = new AddressSettings(this);
     usersService = new UsersService(this);
+    pluginHosts = new Map<string, RuntimeHost>();
 
     constructor(public mainFilename: string, datastore: Level, insecure: http.Server, secure: https.Server, app: express.Application) {
         super(app);
         this.datastore = datastore;
         this.app = app;
 
+        this.pluginHosts.set('python', (_, pluginId, options) => new PythonRuntimeWorker(pluginId, options));
+        this.pluginHosts.set('node', (mainFilename, pluginId, options) => new NodeForkWorker(mainFilename, pluginId, options));
+
         app.disable('x-powered-by');
 
         this.addMiddleware();

package/src/scrypted-main-exports.ts

@@ -4,8 +4,15 @@ import process from 'process';
 import semver from 'semver';
 import { RPCResultError, startPeriodicGarbageCollection } from './rpc';
 import { PluginError } from './plugin/plugin-error';
+import type { Runtime } from './scrypted-server-main';
 
-function start(mainFilename: string) {
+export function isChildProcess() {
+    return process.argv[2] === 'child' || process.argv[2] === 'child-thread'
+}
+
+function start(mainFilename: string, options?: {
+    onRuntimeCreated?: (runtime: Runtime) => Promise<void>,
+}) {
     if (!global.gc) {
         v8.setFlagsFromString('--expose_gc')
         global.gc = vm.runInNewContext("gc");
@@ -47,7 +54,7 @@ function start(mainFilename: string) {
         });
 
         const start = require('./scrypted-server-main').default;
-        return start(mainFilename);
+        return start(mainFilename, options);
     }
 }
 

package/src/scrypted-plugin-main.ts

@@ -25,7 +25,7 @@ function start(mainFilename: string) {
             if (e)
                 reject?.(e);
         }));
-    
+
         peer.transportSafeArgumentTypes.add(Buffer.name);
         peer.addSerializer(net.Socket, net.Socket.name, new SidebandSocketSerializer());
         process.on('message', message => peer.handleMessage(message as RpcMessage));

package/src/scrypted-server-main.ts

@@ -27,6 +27,8 @@ import { setScryptedUserPassword } from './services/users';
 import { sleep } from './sleep';
 import { ONE_DAY_MILLISECONDS, UserToken } from './usertoken';
 
+export type Runtime = ScryptedRuntime;
+
 if (!semver.gte(process.version, '16.0.0')) {
     throw new Error('"node" version out of date. Please update node to v16 or higher.')
 }
@@ -104,7 +106,9 @@ app.use(bodyParser.json())
 // parse some custom thing into a Buffer
 app.use(bodyParser.raw({ type: 'application/zip', limit: 100000000 }) as any)
 
-async function start(mainFilename: string) {
+async function start(mainFilename: string, options?: {
+    onRuntimeCreated?: (runtime: ScryptedRuntime) => Promise<void>,
+}) {
     const volumeDir = getScryptedVolume();
     mkdirp.sync(volumeDir);
     const dbPath = path.join(volumeDir, 'scrypted.db');
@@ -271,6 +275,7 @@ async function start(mainFilename: string) {
     });
 
     const scrypted = new ScryptedRuntime(mainFilename, db, insecure, secure, app);
+    await options?.onRuntimeCreated?.(scrypted);
     await scrypted.start();
 
     listenServerPort('SCRYPTED_SECURE_PORT', SCRYPTED_SECURE_PORT, secure);

package/test/rpc-python-test.ts

@@ -1,9 +1,8 @@
 import child_process from 'child_process';
+import net from 'net';
 import path from 'path';
 import type { Readable, Writable } from "stream";
 import { createDuplexRpcPeer } from '../src/rpc-serializer';
-import assert from 'assert';
-import net from 'net';
 
 async function main() {
     const server = net.createServer(client => {
@@ -21,12 +20,17 @@ async function main() {
     const rpcPeer = createDuplexRpcPeer('node', 'python', cp.stdio[3] as Readable, cp.stdio[4] as Writable);
 
     async function* test() {
-        yield 1;
-        yield 2;
-        yield 3;
+        try {
+            for (let i = 0; ; i++) {
+                yield i;
+            }
+        }
+        finally {
+            console.log('closed');
+        }
     }
 
-    rpcPeer.params['test'] = test();
+    rpcPeer.params['test'] = test;
 
     // const foo = await rpcPeer.getParam('foo');
     // assert.equal(foo, 3);

package/tsconfig.json

@@ -1,5 +1,6 @@
 {
     "compilerOptions": {
+        "declaration": true,
         "module": "commonjs",
         "target": "esnext",
         "noImplicitAny": true,