@scrypted/server 0.0.183 → 0.1.3

package/src/rpc.ts

@@ -43,10 +43,6 @@ interface RpcResult extends RpcMessage {
     result?: any;
 }
 
-interface RpcOob extends RpcMessage {
-    oob: any;
-}
-
 interface RpcRemoteProxyValue {
     __remote_proxy_id: string | undefined;
     __remote_proxy_finalizer_id: string | undefined;
@@ -127,8 +123,9 @@ class RpcProxy implements PrimitiveProxyHandler<any> {
         // undefined is not JSON serializable.
         const method = target() || null;
         const args: any[] = [];
+        const serializationContext: any = {};
         for (const arg of (argArray || [])) {
-            args.push(this.peer.serialize(arg));
+            args.push(this.peer.serialize(arg, serializationContext));
         }
 
         const rpcApply: RpcApply = {
@@ -147,7 +144,7 @@ class RpcProxy implements PrimitiveProxyHandler<any> {
 
         return this.peer.createPendingResult((id, reject) => {
             rpcApply.id = id;
-            this.peer.send(rpcApply, reject);
+            this.peer.send(rpcApply, reject, serializationContext);
         })
     }
 }
@@ -193,8 +190,8 @@ catch (e) {
 }
 
 export interface RpcSerializer {
-    serialize(value: any): any;
-    deserialize(serialized: any): any;
+    serialize(value: any, serializationContext?: any): any;
+    deserialize(serialized: any, serializationContext?: any): any;
 }
 
 interface LocalProxiedEntry {
@@ -204,7 +201,6 @@ interface LocalProxiedEntry {
 
 export class RpcPeer {
     idCounter = 1;
-    onOob?: (oob: any) => void;
     params: { [name: string]: any } = {};
     pendingResults: { [id: string]: Deferred } = {};
     proxyCounter = 1;
@@ -213,7 +209,7 @@ export class RpcPeer {
     remoteWeakProxies: { [id: string]: WeakRef<any> } = {};
     finalizers = new FinalizationRegistry(entry => this.finalize(entry as LocalProxiedEntry));
     nameDeserializerMap = new Map<string, RpcSerializer>();
-    constructorSerializerMap = new Map<string, string>();
+    constructorSerializerMap = new Map<any, string>();
     transportSafeArgumentTypes = RpcPeer.getDefaultTransportSafeArgumentTypes();
 
     static readonly finalizerIdSymbol = Symbol('rpcFinalizerId');
@@ -251,7 +247,7 @@ export class RpcPeer {
     static readonly PROPERTY_PROXY_PROPERTIES = '__proxy_props';
     static readonly PROPERTY_JSON_COPY_SERIALIZE_CHILDREN = '__json_copy_serialize_children';
 
-    constructor(public selfName: string, public peerName: string, public send: (message: RpcMessage, reject?: (e: Error) => void) => void) {
+    constructor(public selfName: string, public peerName: string, public send: (message: RpcMessage, reject?: (e: Error) => void, serializationContext?: any) => void) {
     }
 
     createPendingResult(cb: (id: string, reject: (e: Error) => void) => void): Promise<any> {
@@ -310,13 +306,6 @@ export class RpcPeer {
         });
     }
 
-    sendOob(oob: any) {
-        this.send({
-            type: 'oob',
-            oob,
-        } as RpcOob)
-    }
-
     evalLocal<T>(script: string, filename?: string, coercedParams?: { [name: string]: any }): T {
         const params = Object.assign({}, this.params, coercedParams);
         let compile: CompileFunction;
@@ -339,7 +328,7 @@ export class RpcPeer {
         result.message = (e as Error).message || 'no message';
     }
 
-    deserialize(value: any): any {
+    deserialize(value: any, deserializationContext: any): any {
         if (!value)
             return value;
 
@@ -347,7 +336,7 @@ export class RpcPeer {
         if (copySerializeChildren) {
             const ret: any = {};
             for (const [key, val] of Object.entries(value)) {
-                ret[key] = this.deserialize(val);
+                ret[key] = this.deserialize(val, deserializationContext);
             }
             return ret;
         }
@@ -370,17 +359,17 @@ export class RpcPeer {
 
         const deserializer = this.nameDeserializerMap.get(__remote_constructor_name);
         if (deserializer) {
-            return deserializer.deserialize(__serialized_value);
+            return deserializer.deserialize(__serialized_value, deserializationContext);
         }
 
         return value;
     }
 
-    serialize(value: any): any {
+    serialize(value: any, serializationContext: any): any {
         if (value?.[RpcPeer.PROPERTY_JSON_COPY_SERIALIZE_CHILDREN] === true) {
             const ret: any = {};
             for (const [key, val] of Object.entries(value)) {
-                ret[key] = this.serialize(val);
+                ret[key] = this.serialize(val, serializationContext);
             }
             return ret;
         }
@@ -419,7 +408,7 @@ export class RpcPeer {
             const serializer = this.nameDeserializerMap.get(serializerMapName);
             if (!serializer)
                 throw new Error('serializer not found for ' + serializerMapName);
-            const serialized = serializer.serialize(value);
+            const serialized = serializer.serialize(value, serializationContext);
             const ret: RpcRemoteProxyValue = {
                 __remote_proxy_id: undefined,
                 __remote_proxy_finalizer_id: undefined,
@@ -464,17 +453,18 @@ export class RpcPeer {
         return proxy;
     }
 
-    async handleMessage(message: RpcMessage) {
+    async handleMessage(message: RpcMessage, deserializationContext?: any) {
         try {
             switch (message.type) {
                 case 'param': {
                     const rpcParam = message as RpcParam;
+                    const serializationContext: any = {};
                     const result: RpcResult = {
                         type: 'result',
                         id: rpcParam.id,
-                        result: this.serialize(this.params[rpcParam.param])
+                        result: this.serialize(this.params[rpcParam.param], serializationContext)
                     };
-                    this.send(result);
+                    this.send(result, undefined, serializationContext);
                     break;
                 }
                 case 'apply': {
@@ -483,6 +473,7 @@ export class RpcPeer {
                         type: 'result',
                         id: rpcApply.id || '',
                     };
+                    const serializationContext: any = {};
 
                     try {
                         const target = this.localProxyMap[rpcApply.proxyId];
@@ -491,7 +482,7 @@ export class RpcPeer {
 
                         const args = [];
                         for (const arg of (rpcApply.args || [])) {
-                            args.push(this.deserialize(arg));
+                            args.push(this.deserialize(arg, deserializationContext));
                         }
 
                         let value: any;
@@ -505,7 +496,7 @@ export class RpcPeer {
                             value = await target(...args);
                         }
 
-                        result.result = this.serialize(value);
+                        result.result = this.serialize(value, serializationContext);
                     }
                     catch (e) {
                         // console.error('failure', rpcApply.method, e);
@@ -513,7 +504,7 @@ export class RpcPeer {
                     }
 
                     if (!rpcApply.oneway)
-                        this.send(result);
+                        this.send(result, undefined, serializationContext);
                     break;
                 }
                 case 'result': {
@@ -530,7 +521,7 @@ export class RpcPeer {
                         deferred.reject(e);
                         return;
                     }
-                    deferred.resolve(this.deserialize(rpcResult.result));
+                    deferred.resolve(this.deserialize(rpcResult.result, deserializationContext));
                     break;
                 }
                 case 'finalize': {
@@ -547,11 +538,6 @@ export class RpcPeer {
                     }
                     break;
                 }
-                case 'oob': {
-                    const rpcOob = message as RpcOob;
-                    this.onOob?.(rpcOob.oob);
-                    break;
-                }
                 default:
                     throw new Error(`unknown rpc message type ${message.type}`);
             }

package/src/runtime.ts

@@ -6,7 +6,7 @@ import { Plugin, PluginDevice, ScryptedAlert } from './db-types';
 import { getState, ScryptedStateManager, setState } from './state';
 import { Request, Response } from 'express';
 import { createResponseInterface } from './http-interfaces';
-import http, { ServerResponse } from 'http';
+import http, { ServerResponse, IncomingHttpHeaders } from 'http';
 import https from 'https';
 import express from 'express';
 import { LogEntry, Logger, makeAlertId } from './logger';
@@ -25,20 +25,22 @@ import semver from 'semver';
 import { ServiceControl } from './services/service-control';
 import { Alerts } from './services/alerts';
 import { Info } from './services/info';
-import io from 'engine.io';
+import * as io from 'engine.io';
 import { spawn as ptySpawn } from 'node-pty';
 import rimraf from 'rimraf';
 import { getPluginVolume } from './plugin/plugin-volume';
 import { PluginHttp } from './plugin/plugin-http';
 import AdmZip from 'adm-zip';
 import path from 'path';
+import { CORSControl, CORSServer } from './services/cors';
+import { IOServer, IOServerSocket } from './io';
 
 interface DeviceProxyPair {
     handler: PluginDeviceProxyHandler;
     proxy: ScryptedDevice;
 }
 
-const MIN_SCRYPTED_CORE_VERSION = 'v0.0.238';
+const MIN_SCRYPTED_CORE_VERSION = 'v0.1.5';
 const PLUGIN_DEVICE_STATE_VERSION = 2;
 
 interface HttpPluginData {
@@ -56,9 +58,18 @@ export class ScryptedRuntime extends PluginHttp<HttpPluginData> {
     devicesLogger = this.logger.getLogger('device', 'Devices');
     wss = new WebSocketServer({ noServer: true });
     wsAtomic = 0;
-    shellio = io(undefined, {
+    shellio: IOServer = new io.Server({
         pingTimeout: 120000,
+        perMessageDeflate: true,
+        cors: (req, callback) => {
+            const header = this.getAccessControlAllowOrigin(req.headers);
+            callback(undefined, {
+                origin: header,
+                credentials: true,
+            })
+        },
     });
+    cors: CORSServer[] = [];
 
     constructor(datastore: Level, insecure: http.Server, secure: https.Server, app: express.Application) {
         super(app);
@@ -67,6 +78,48 @@ export class ScryptedRuntime extends PluginHttp<HttpPluginData> {
 
         app.disable('x-powered-by');
 
+        this.app.options(['/endpoint/@:owner/:pkg/engine.io/api/activate', '/endpoint/@:owner/:pkg/engine.io/api/activate'], (req, res) => {
+            this.addAccessControlHeaders(req, res);
+            res.setHeader('Access-Control-Allow-Methods', 'POST, OPTIONS');
+            res.setHeader('Access-Control-Allow-Headers', 'Content-Type, Authorization, Content-Length, X-Requested-With');
+            res.send(200);
+        });
+
+        this.app.post(['/endpoint/@:owner/:pkg/engine.io/api/activate', '/endpoint/@:owner/:pkg/engine.io/api/activate'], (req, res) => {
+            const { username } = (req as any);
+            if (!username) {
+                res.status(401);
+                res.send('Not Authorized');
+                return;
+            }
+
+            const { owner, pkg } = req.params;
+            let endpoint = pkg;
+            if (owner)
+                endpoint = `@${owner}/${endpoint}`;
+
+            const { id } = req.body;
+            try {
+                const host = this.plugins?.[endpoint];
+                if (!host)
+                    throw new Error('invalid plugin');
+                // @ts-expect-error
+                const socket: IOServerSocket = host.io.clients[id];
+                if (!socket)
+                    throw new Error('invalid socket');
+                socket.emit('/api/activate');
+                res.send({
+                    id,
+                })
+            }
+            catch (e) {
+                res.status(500);
+                res.end();
+            }
+        });
+
+        this.addMiddleware();
+
         app.get('/web/oauth/callback', (req, res) => {
             this.oauthCallback(req, res);
         });
@@ -122,6 +175,34 @@ export class ScryptedRuntime extends PluginHttp<HttpPluginData> {
         }, 60 * 60 * 1000);
     }
 
+    addAccessControlHeaders(req: http.IncomingMessage, res: http.ServerResponse) {
+        res.setHeader('Vary', 'Origin,Referer');
+        const header = this.getAccessControlAllowOrigin(req.headers);
+        if (header)
+            res.setHeader('Access-Control-Allow-Origin', header);
+    }
+
+    getAccessControlAllowOrigin(headers: http.IncomingHttpHeaders) {
+        let { origin, referer } = headers;
+        if (!origin && referer) {
+            try {
+                const u = new URL(headers.referer)
+                origin = u.origin;
+            }
+            catch (e) {
+                return;
+            }
+        }
+        if (!origin)
+            return;
+        const servers: string[] = process.env.SCRYPTED_ACCESS_CONTROL_ALLOW_ORIGINS?.split(',') || [];
+        servers.push(...Object.values(this.cors).map(entry => entry.server));
+        if (!servers.includes(origin))
+            return;
+
+        return origin;
+    }
+
     getDeviceLogger(device: PluginDevice): Logger {
         return this.devicesLogger.getLogger(device._id, getState(device, ScryptedInterfaceProperty.name));
     }
@@ -311,6 +392,8 @@ export class ScryptedRuntime extends PluginHttp<HttpPluginData> {
                 return this.logger;
             case 'alerts':
                 return new Alerts(this);
+            case 'cors':
+                return new CORSControl(this);
         }
     }
 

package/src/scrypted-server-main.ts

@@ -8,7 +8,7 @@ import net from 'net';
 import { ScryptedRuntime } from './runtime';
 import level from './level';
 import { Plugin, ScryptedUser, Settings } from './db-types';
-import { SCRYPTED_DEBUG_PORT, SCRYPTED_INSECURE_PORT, SCRYPTED_SECURE_PORT } from './server-settings';
+import { getHostAddresses, SCRYPTED_DEBUG_PORT, SCRYPTED_INSECURE_PORT, SCRYPTED_SECURE_PORT } from './server-settings';
 import crypto from 'crypto';
 import cookieParser from 'cookie-parser';
 import axios from 'axios';
@@ -20,7 +20,6 @@ import { install as installSourceMapSupport } from 'source-map-support';
 import httpAuth from 'http-auth';
 import semver from 'semver';
 import { Info } from './services/info';
-import { getAddresses } from './addresses';
 import { sleep } from './sleep';
 import { createSelfSignedCertificate, CURRENT_SELF_SIGNED_CERTIFICATE_VERSION } from './cert';
 import { PluginError } from './plugin/plugin-error';
@@ -55,7 +54,7 @@ let workerInspectPort: number = undefined;
 
 async function doconnect(): Promise<net.Socket> {
     return new Promise((resolve, reject) => {
-        const target = net.connect(workerInspectPort);
+        const target = net.connect(workerInspectPort, '127.0.0.1');
         target.once('error', reject)
         target.once('connect', () => resolve(target))
     })
@@ -123,7 +122,6 @@ async function start() {
         certSetting = await db.upsert(certSetting);
     }
 
-
     const basicAuth = httpAuth.basic({
         realm: 'Scrypted',
     }, async (username, password, callback) => {
@@ -184,6 +182,7 @@ async function start() {
             // }
 
             res.locals.username = username;
+            (req as any).username = username;
         }
         next();
     });
@@ -193,6 +192,7 @@ async function start() {
         if (req.protocol === 'https' && req.headers.authorization && req.headers.authorization.toLowerCase()?.indexOf('basic') !== -1) {
             const basicChecker = basicAuth.check((req) => {
                 res.locals.username = req.user;
+                (req as any).username = req.user;
                 next();
             });
 
@@ -226,7 +226,7 @@ async function start() {
 
     console.log('#######################################################');
     console.log(`Scrypted Server (Local)   : https://localhost:${SCRYPTED_SECURE_PORT}/`);
-    for (const address of getAddresses()) {
+    for (const address of getHostAddresses(true, true)) {
         console.log(`Scrypted Server (Remote)  : https://${address}:${SCRYPTED_SECURE_PORT}/`);
     }
     console.log(`Version:       : ${await new Info().getVersion()}`);
@@ -360,10 +360,20 @@ async function start() {
 
     let hasLogin = await db.getCount(ScryptedUser) > 0;
 
+    app.options('/login', (req, res) => {
+        scrypted.addAccessControlHeaders(req, res);
+        res.setHeader('Access-Control-Allow-Methods', 'GET, POST, OPTIONS');
+        res.setHeader('Access-Control-Allow-Headers', 'Content-Type, Authorization, Content-Length, X-Requested-With');
+        res.send(200);
+    });
+
     app.post('/login', async (req, res) => {
+        scrypted.addAccessControlHeaders(req, res);
+
         const { username, password, change_password } = req.body;
         const timestamp = Date.now();
         const maxAge = 86400000;
+        const addresses = getHostAddresses(true, true).map(address => `https://${address}:${SCRYPTED_SECURE_PORT}`);
 
         if (hasLogin) {
             const user = await db.tryGet(ScryptedUser, username);
@@ -390,9 +400,11 @@ async function start() {
             const login_user_token = `${username}#${timestamp}`;
             res.cookie('login_user_token', login_user_token, {
                 maxAge,
-                secure: true,
+                // enabling this will disable insecure http login...
+                // secure: true,
                 signed: true,
                 httpOnly: true,
+                sameSite: 'none',
             });
 
             if (change_password) {
@@ -405,6 +417,7 @@ async function start() {
             res.send({
                 username,
                 expiration: maxAge,
+                addresses,
             });
 
             return;
@@ -423,25 +436,32 @@ async function start() {
         user.salt = crypto.randomBytes(64).toString('base64');
         user.passwordHash = crypto.createHash('sha256').update(user.salt + password).digest().toString('hex');
         user.passwordDate = timestamp;
+        user.token = crypto.randomBytes(16).toString('hex');
         await db.upsert(user);
         hasLogin = true;
 
         const login_user_token = `${username}#${timestamp}`
         res.cookie('login_user_token', login_user_token, {
             maxAge,
-            secure: true,
+            // enabling this will disable insecure http login...
+            // secure: true,
             signed: true,
             httpOnly: true,
+            sameSite: 'none',
         });
 
         res.send({
             username,
+            token: user.token,
             expiration: maxAge,
+            addresses,
         });
     });
 
-
     app.get('/login', async (req, res) => {
+        scrypted.addAccessControlHeaders(req, res);
+
+        const addresses = getHostAddresses(true, true).map(address => `https://${address}:${SCRYPTED_SECURE_PORT}`);
         if (req.protocol === 'https' && req.headers.authorization) {
             const username = await new Promise(resolve => {
                 const basicChecker = basicAuth.check((req) => {
@@ -484,31 +504,10 @@ async function start() {
             return;
         }
 
-        // this database lookup on every web request is not necessary, the cookie
-        // itself is the auth, and is signed. furthermore, this is currently
-        // a single user setup anywyas. revisit this at some point when
-        // multiple users are implemented.
-
-        // const user = await db.tryGet(ScryptedUser, username);
-        // if (!user) {
-        //     res.send({
-        //         error: 'User not found.',
-        //         hasLogin,
-        //     })
-        //     return;
-        // }
-
-        // if (timestamp < user.passwordDate) {
-        //     res.send({
-        //         error: 'Login invalid. Password has changed.',
-        //         hasLogin,
-        //     })
-        //     return;
-        // }
-
         res.send({
             expiration: 86400000 - (Date.now() - timestamp),
             username,
+            addresses,
         })
     });
 

package/src/server-settings.ts

@@ -1,24 +1,70 @@
 import os from 'os';
+import * as nodeIp from 'ip';
 
 export const SCRYPTED_INSECURE_PORT = parseInt(process.env.SCRYPTED_INSECURE_PORT) || 11080;
 export const SCRYPTED_SECURE_PORT = parseInt(process.env.SCRYPTED_SECURE_PORT) || 10443;
 export const SCRYPTED_DEBUG_PORT = parseInt(process.env.SCRYPTED_DEBUG_PORT) || 10081;
 
 export function getIpAddress(): string {
-    const ni = os.networkInterfaces();
-    for (const i of [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]) {
-        let ipv4: os.NetworkInterfaceInfo;
-        let ipv6: os.NetworkInterfaceInfo;
-        for (const en of (ni[`en${i}`] || [])) {
-            if (en.family === 'IPv4')
-                ipv4 = en;
-            else if (en.family === 'IPv6')
-                ipv6 = en;
-        }
-
-        if (ipv4 || ipv6)
-            return (ipv4 || ipv6).address;
-    }
-
-    return '127.0.0.1';
+    return nodeIp.address();
+}
+
+function normalizeFamilyNodeV18(family: string|number) {
+    if (family === 'IPv4')
+        return 4;
+    if (family === 'IPv6')
+        return 6;
+    return family;
+}
+
+function nodeIpAddress(family: number): string[] {
+    // https://chromium.googlesource.com/external/webrtc/+/master/rtc_base/network.cc#236
+    const costlyNetworks = ["ipsec", "tun", "utun", "tap"];
+
+    const ignoreNetworks = [
+        // seen these on macos
+        'llw',
+        'awdl',
+
+        ...costlyNetworks,
+    ];
+
+    const interfaces = os.networkInterfaces();
+
+    const all = Object.keys(interfaces)
+        .map((nic) => {
+            for (const costly of ignoreNetworks) {
+                if (nic.startsWith(costly)) {
+                    return {
+                        nic,
+                        addresses: [],
+                    };
+                }
+            }
+            const addresses = interfaces[nic]!.filter(
+                (details) =>
+                    normalizeFamilyNodeV18(details.family) === family
+                    && !nodeIp.isLoopback(details.address)
+            );
+            return {
+                nic,
+                addresses: addresses.map((address) => address.address),
+            };
+        })
+        .filter((address) => !!address);
+
+    // os.networkInterfaces doesn't actually return addresses in a good order.
+    // have seen instances where en0 (ethernet) is after en1 (wlan), etc.
+    // eth0 > eth1
+    all.sort((a, b) => a.nic.localeCompare(b.nic));
+    return Object.values(all)
+        .map((entry) => entry.addresses)
+        .flat();
+}
+
+export function getHostAddresses(useIpv4: boolean, useIpv6: boolean) {
+    const address: string[] = [];
+    if (useIpv4) address.push(...nodeIpAddress(4));
+    if (useIpv6) address.push(...nodeIpAddress(6));
+    return address;
 }

package/src/services/cors.ts

@@ -0,0 +1,19 @@
+import { ScryptedRuntime } from "../runtime";
+
+export interface CORSServer {
+    tag: string;
+    server: string;
+}
+
+export class CORSControl {
+    constructor(public runtime: ScryptedRuntime) {
+    }
+
+    async getCORS(): Promise<CORSServer[]> {
+        return this.runtime.cors;
+    }
+
+    async setCORS(servers: CORSServer[]) {
+        this.runtime.cors = servers;
+    }
+}

package/dist/addresses.js

@@ -1,12 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getAddresses = void 0;
-const os_1 = __importDefault(require("os"));
-function getAddresses() {
-    return Object.entries(os_1.default.networkInterfaces()).filter(([iface]) => iface.startsWith('en') || iface.startsWith('eth') || iface.startsWith('wlan')).map(([_, addr]) => addr).flat().map(info => info.address).filter(address => address);
-}
-exports.getAddresses = getAddresses;
-//# sourceMappingURL=addresses.js.map

package/dist/addresses.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"addresses.js","sourceRoot":"","sources":["../src/addresses.ts"],"names":[],"mappings":";;;;;;AAAA,4CAAoB;AAEpB,SAAgB,YAAY;IACxB,OAAO,MAAM,CAAC,OAAO,CAAC,YAAE,CAAC,iBAAiB,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,KAAK,CAAC,EAAE,EAAE,CAAC,KAAK,CAAC,UAAU,CAAC,IAAI,CAAC,IAAI,KAAK,CAAC,UAAU,CAAC,KAAK,CAAC,IAAI,KAAK,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC,CAAC,IAAI,EAAE,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,EAAE,CAAC,OAAO,CAAC,CAAC;AAC1O,CAAC;AAFD,oCAEC"}

package/src/addresses.ts

@@ -1,5 +0,0 @@
-import os from 'os';
-
-export function getAddresses() {
-    return Object.entries(os.networkInterfaces()).filter(([iface]) => iface.startsWith('en') || iface.startsWith('eth') || iface.startsWith('wlan')).map(([_, addr]) => addr).flat().map(info => info.address).filter(address => address);
-}