@aloma.io/integration-sdk 3.0.2 → 3.0.3

package/build/builder/index.d.mts

@@ -1,4 +1,4 @@
-import RuntimeContext from './runtime-context.mjs';
+import RuntimeContext from "./runtime-context.mjs";
 export declare class Builder {
     private data;
     config(arg: any): Builder;

package/build/builder/index.mjs

@@ -1,8 +1,8 @@
-import fs from 'node:fs';
-import parseTypes from './transform/index.mjs';
-import RuntimeContext from './runtime-context.mjs';
-import { fileURLToPath } from 'node:url';
-import path from 'node:path';
+import fs from "node:fs";
+import parseTypes from "./transform/index.mjs";
+import RuntimeContext from "./runtime-context.mjs";
+import { fileURLToPath } from "node:url";
+import path from "node:path";
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const notEmpty = (what, name) => {
     if (!what?.trim())
@@ -10,7 +10,9 @@ const notEmpty = (what, name) => {
     return what;
 };
 export class Builder {
-    data = { controller: './build/controller/.controller-for-types.mts' };
+    data = {
+        controller: "./build/controller/.controller-for-types.mts",
+    };
     config(arg) {
         this.data.config = arg;
         return this;
@@ -27,17 +29,19 @@ export class Builder {
         await this.parsePackageJson();
         await this.discoverTypes();
         // @ts-ignore
-        const Controller = (await import(__dirname + '/../../../../../build/controller/index.mjs')).default;
+        const Controller = (await import(__dirname + "/../../../../../build/controller/index.mjs")).default;
         return new RuntimeContext(new Controller(), this.data);
     }
     async parsePackageJson() {
         const data = this.data;
-        const packageJson = JSON.parse(fs.readFileSync(__dirname + '/../../../../../package.json', { encoding: 'utf-8' }));
-        notEmpty(data.id = packageJson.connectorId, 'id');
-        notEmpty(data.version = packageJson.version, 'version');
+        const packageJson = JSON.parse(fs.readFileSync(__dirname + "/../../../../../package.json", {
+            encoding: "utf-8",
+        }));
+        notEmpty((data.id = packageJson.connectorId), "id");
+        notEmpty((data.version = packageJson.version), "version");
     }
     async discoverTypes() {
-        notEmpty(this.data.controller, 'controller');
+        notEmpty(this.data.controller, "controller");
         const content = fs.readFileSync(this.data.controller);
         const { text, methods } = parseTypes(this.data.controller);
         this.data.types = text;

package/build/builder/runtime-context.d.mts

@@ -1,4 +1,4 @@
-import { AbstractController } from '../controller/index.mjs';
+import { AbstractController } from "../controller/index.mjs";
 export default class RuntimeContext {
     private controller;
     private data;

package/build/builder/runtime-context.mjs

@@ -1,5 +1,5 @@
-import { AbstractController } from '../controller/index.mjs';
-import { Connector } from '../internal/index.cjs';
+import { AbstractController } from "../controller/index.mjs";
+import { Connector } from "../internal/index.cjs";
 export default class RuntimeContext {
     controller;
     data;
@@ -10,7 +10,7 @@ export default class RuntimeContext {
     async start() {
         const controller = this.controller;
         if (!(controller instanceof AbstractController))
-            throw new Error('the controller needs to extend AbstractController');
+            throw new Error("the controller needs to extend AbstractController");
         const data = this.data;
         const connector = new Connector({
             id: data.id,
@@ -19,7 +19,12 @@ export default class RuntimeContext {
         });
         const configuration = connector.configure().config(data.config || {});
         const resolvers = {};
-        const methods = [...data.methods, '__endpoint', '__configQuery', '__default'];
+        const methods = [
+            ...data.methods,
+            "__endpoint",
+            "__configQuery",
+            "__default",
+        ];
         methods.forEach((method) => {
             resolvers[method] = async (args) => {
                 if (!methods.includes(method))
@@ -27,9 +32,7 @@ export default class RuntimeContext {
                 return controller[method](args);
             };
         });
-        configuration
-            .types(data.types)
-            .resolvers(resolvers);
+        configuration.types(data.types).resolvers(resolvers);
         if (data.options?.endpoint?.enabled) {
             configuration.endpoint((arg) => controller.__endpoint(arg));
         }

package/build/builder/transform/index.mjs

@@ -1,19 +1,19 @@
-import { parseFromFiles } from '@ts-ast-parser/core';
+import { parseFromFiles } from "@ts-ast-parser/core";
 const transform = (meta) => {
     if (!meta?.length)
-        throw new Error('metadata is empty');
+        throw new Error("metadata is empty");
     meta = meta[0];
     if (meta.getDeclarations()?.length !== 1) {
-        throw new Error('connector file needs to export default class');
+        throw new Error("connector file needs to export default class");
     }
     const methods = {};
     const decl = meta.getDeclarations()[0];
     const members = decl.getMethods().filter((member) => {
         return !(member.isStatic() ||
             member.isInherited() ||
-            member.getKind() !== 'Method' ||
-            member.getModifier() !== 'public' ||
-            member.getName().startsWith('_'));
+            member.getKind() !== "Method" ||
+            member.getModifier() !== "public" ||
+            member.getName().startsWith("_"));
     });
     const text = members
         .map((member) => {
@@ -22,13 +22,13 @@ const transform = (meta) => {
             .getSignatures()
             .map((sig) => {
             const docs = sig.getJSDoc().serialize() || [];
-            const desc = docs.find((what) => what.kind === 'description')?.value;
+            const desc = docs.find((what) => what.kind === "description")?.value;
             const paramDocs = docs
-                .filter((what) => what.kind === 'param')
+                .filter((what) => what.kind === "param")
                 .map((what) => {
-                return ` * @param {${what.value.type}} ${what.value.name} - ${what.value.description || ''}`;
+                return ` * @param {${what.value.type}} ${what.value.name} - ${what.value.description || ""}`;
             })
-                .join('\n') || ' *';
+                .join("\n") || " *";
             const params = sig
                 .getParameters()
                 .map((param) => {
@@ -38,32 +38,32 @@ const transform = (meta) => {
                         const tmp = param
                             .getNamedElements()
                             .map((p) => {
-                            const defaultVal = p.default != null ? ' = ' + p.default : '';
+                            const defaultVal = p.default != null ? " = " + p.default : "";
                             return `${p.name}${defaultVal}`;
                         })
-                            .join('; ');
+                            .join("; ");
                         return `{${tmp}}: ${param.getType().text}`;
                     case false:
                         return `${param.getName()}: ${param.getType().text}`;
                 }
             })
-                .join(', ');
+                .join(", ");
             const retVal = sig
                 .getReturnType()
-                .type.text.replace(/^Promise</, '')
-                .replace(/>$/, '');
+                .type.text.replace(/^Promise</, "")
+                .replace(/>$/, "");
             return `
 /**
- * ${desc || ''}
+ * ${desc || ""}
  *
 ${paramDocs}
  **/    
 declare function ${member.getName()}(${params}): ${retVal};
       `;
         })
-            .join('\n');
+            .join("\n");
     })
-        .join('');
+        .join("");
     return { text, methods: Object.keys(methods) };
 };
 export default (path) => {

package/build/cli.d.mts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/build/cli.mjs

@@ -0,0 +1,93 @@
+#!/usr/bin/env node
+import { Command } from "commander";
+import fs from "node:fs";
+import { fileURLToPath } from "node:url";
+import path from "node:path";
+import JWE from './internal/util/jwe/index.cjs';
+import util from 'node:util';
+import ChildProcess from 'node:child_process';
+const exec = util.promisify(ChildProcess.exec);
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const files = [
+    { name: "index.mts", dir: "src/controller" },
+    { name: "index.mts", dir: "src" },
+    { name: "package.json", dir: "" },
+    { name: "Containerfile", dir: "" },
+    { name: "entrypoint.sh", dir: "" },
+    { name: "tsconfig.json", dir: "" },
+];
+const extract = ({ target, name, connectorId }) => {
+    const source = `${__dirname}/../template/connector/`;
+    if (!fs.existsSync(source)) {
+        throw new Error(`source ${source} does not exist`);
+    }
+    files.forEach(({ name, dir }) => {
+        if (dir) {
+            fs.mkdirSync(`${target}/${dir}`, { recursive: true });
+        }
+        const content = fs.readFileSync(`${source}/${dir}/${name}`, {
+            encoding: "utf-8",
+        });
+        fs.writeFileSync(`${target}/${dir}/${name}`, content);
+    });
+    const content = JSON.parse(fs.readFileSync(`${target}/package.json`, { encoding: "utf-8" }));
+    content.name = name;
+    content.connectorId = connectorId;
+    fs.writeFileSync(`${target}/package.json`, JSON.stringify(content, null, 2));
+    fs.writeFileSync(`${target}/.gitignore`, `.DS_Store
+node_modules
+build
+.env`);
+};
+const generateKeys = async ({ target }) => {
+    const jwe = new JWE({});
+    await jwe.newPair();
+    const priv = await jwe.exportPrivateAsBase64();
+    const pub = await jwe.exportPublicAsBase64();
+    const content = `REGISTRATION_TOKEN=
+PRIVATE_KEY=${priv}
+PUBLIC_KEY=${pub}
+`;
+    fs.writeFileSync(`${target}/.env`, content);
+};
+const program = new Command();
+program
+    .name("npx @aloma.io/integration-sdk")
+    .description("aloma.io integration sdk")
+    .version("0.8.0")
+    .showHelpAfterError();
+program
+    .command("create")
+    .description("Create a new connector project")
+    .argument("<name>", "name of the project")
+    .requiredOption("--connector-id <id>", "id of the connector")
+    .action(async (name, options) => {
+    name = name.replace(/[\/\.]/gi, "");
+    if (!name)
+        throw new Error("name is empty");
+    const target = `${process.cwd()}/${name}`;
+    fs.mkdirSync(target);
+    console.log('Creating connector ...');
+    extract({ ...options, target, name });
+    console.log('Generating keys ...');
+    await generateKeys({ target });
+    console.log('Installing dependencies ...');
+    await exec(`cd ${target}; yarn`);
+    console.log('Building ...');
+    await exec(`cd ${target}; yarn build`);
+    console.log(`
+Success!
+      
+1.) Add the connector to a workspace
+2.) Edit ./${name}/.env and insert the registration token
+3.) Start the connector with cd ./${name}/; yarn start`);
+});
+program
+    .command("build")
+    .description("Build the current connector project")
+    .action(async (str, options) => {
+    const { stdout, stderr } = await exec(`rm -rf build; mkdir -p build/controller; cp ./src/controller/index.mts ./build/controller/.controller-for-types.mts;`);
+    if (stdout)
+        console.log(stdout);
+});
+program.parse();

package/build/controller/index.mjs

@@ -7,19 +7,19 @@ export class AbstractController {
         return Promise.resolve({});
     }
     fallback(arg) {
-        throw new Error('method not found');
+        throw new Error("method not found");
     }
     endpoint(arg) {
-        throw new Error('method not found');
+        throw new Error("method not found");
     }
     async newTask(name, data) {
-        throw new Error('not implemented');
+        throw new Error("not implemented");
     }
     getClient({ baseUrl }) {
-        throw new Error('not implemented');
+        throw new Error("not implemented");
     }
     async updateTask(name, data) {
-        throw new Error('not implemented');
+        throw new Error("not implemented");
     }
     async __endpoint(arg) {
         return this.endpoint(arg);

package/build/index.d.mts

@@ -1,2 +1,2 @@
-export * from './builder/index.mjs';
-export * from './controller/index.mjs';
+export * from "./builder/index.mjs";
+export * from "./controller/index.mjs";

package/build/index.mjs

@@ -1,2 +1,2 @@
-export * from './builder/index.mjs';
-export * from './controller/index.mjs';
+export * from "./builder/index.mjs";
+export * from "./controller/index.mjs";

package/build/internal/dispatcher/index.cjs

@@ -14,26 +14,26 @@ class Dispatcher {
                 oauth: true,
                 fields: {
                     oauthResult: {
-                        name: 'OAuth Result',
-                        placeholder: 'will be set by finishing the oauth flow',
-                        type: 'managed',
+                        name: "OAuth Result",
+                        placeholder: "will be set by finishing the oauth flow",
+                        type: "managed",
                     },
                 },
             });
             return this;
         }
         if (!arg.authorizationURL)
-            throw new Error('need a authorizationURL');
+            throw new Error("need a authorizationURL");
         if (!arg.tokenURL && !arg.finishOAuth)
-            throw new Error('need a tokenURL or finishOAuth()');
+            throw new Error("need a tokenURL or finishOAuth()");
         this._oauth = { ...arg };
         this.config({
             oauth: true,
             fields: {
                 oauthResult: {
-                    name: 'OAuth Result',
-                    placeholder: 'will be set by finishing the oauth flow',
-                    type: 'managed',
+                    name: "OAuth Result",
+                    placeholder: "will be set by finishing the oauth flow",
+                    type: "managed",
                 },
             },
         });
@@ -41,14 +41,14 @@ class Dispatcher {
             this.config({
                 fields: {
                     clientId: {
-                        name: 'OAuth Client ID',
-                        placeholder: 'e.g. 1234',
-                        type: 'line',
+                        name: "OAuth Client ID",
+                        placeholder: "e.g. 1234",
+                        type: "line",
                     },
                     clientSecret: {
-                        name: 'OAuth Client Secret',
-                        placeholder: 'e.g. axd5xde',
-                        type: 'line',
+                        name: "OAuth Client Secret",
+                        placeholder: "e.g. axd5xde",
+                        type: "line",
                     },
                 },
             });
@@ -72,9 +72,9 @@ class Dispatcher {
         this.config({
             fields: {
                 _endpointToken: {
-                    name: 'Endpoint Token (set to enable the endpoint)',
-                    placeholder: 'e.g. 1234',
-                    type: 'line',
+                    name: "Endpoint Token (set to enable the endpoint)",
+                    placeholder: "e.g. 1234",
+                    type: "line",
                     plain: true,
                     optional: true,
                 },
@@ -84,19 +84,19 @@ class Dispatcher {
         return this;
     }
     startOAuth() {
-        throw new Error('oauth not configured');
+        throw new Error("oauth not configured");
     }
     finishOAuth() {
-        throw new Error('oauth not configured');
+        throw new Error("oauth not configured");
     }
     build() {
         if (!this._types || !this._resolvers)
-            throw new Error('missing types or resolvers');
+            throw new Error("missing types or resolvers");
         var local = this;
         const _resolvers = { ...this._resolvers };
         const main = this._main || (() => { });
         const start = async (transport) => {
-            console.log('starting ...');
+            console.log("starting ...");
             await main(transport);
         };
         const resolveMethod = (query) => {
@@ -110,33 +110,44 @@ class Dispatcher {
             if (!Array.isArray(query))
                 query = [query];
             query = query
-                .filter((what) => !!what?.trim() && !['constructor', '__proto__', 'toString', 'toSource', 'prototype'].includes(what))
+                .filter((what) => !!what?.trim() &&
+                ![
+                    "constructor",
+                    "__proto__",
+                    "toString",
+                    "toSource",
+                    "prototype",
+                ].includes(what))
                 .slice(0, 20);
             const method = resolveMethod(query);
             if (!method && !_resolvers.__default)
                 throw new Error(`${query} not found`);
-            return method ? method(variables) : _resolvers.__default(variables ? { ...variables, __method: query } : variables);
+            return method
+                ? method(variables)
+                : _resolvers.__default(variables ? { ...variables, __method: query } : variables);
         };
         const introspect = () => local._types;
         const configSchema = () => local._config;
         const processPacket = async (packet) => {
             switch (packet.method()) {
-                case 'connector.introspect':
+                case "connector.introspect":
                     const intro = await introspect({});
                     return { configSchema: local._config, introspect: intro };
-                case 'connector.start-oauth':
+                case "connector.start-oauth":
                     return await local.startOAuth(packet.args());
-                case 'connector.finish-oauth':
+                case "connector.finish-oauth":
                     return await local.finishOAuth(packet.args());
-                case 'connector.query':
+                case "connector.query":
                     const ret = await execute(packet.args());
-                    return typeof ret === 'object' && !Array.isArray(ret) ? ret : { [packet.args().query]: ret };
-                case 'connector.set-config':
+                    return typeof ret === "object" && !Array.isArray(ret)
+                        ? ret
+                        : { [packet.args().query]: ret };
+                case "connector.set-config":
                     await local.onConfig({ ...packet.args().secrets });
                     return;
             }
             console.dir(packet, { depth: null });
-            throw new Error('cannot handle packet');
+            throw new Error("cannot handle packet");
         };
         return {
             introspect,

package/build/internal/index.cjs

@@ -1,27 +1,27 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 // @ts-nocheck
-require('dotenv').config();
-const fs = require('fs');
-const { Config } = require('./websocket/config.cjs');
-const { Connection } = require('./websocket/connection/index.cjs');
-const { Transport } = require('./websocket/transport/index.cjs');
-const { Dispatcher } = require('./dispatcher/index.cjs');
-const { WebsocketConnector } = require('./websocket/index.cjs');
-const JWE = require('./util/jwe/index.cjs');
-const fetch = require('node-fetch');
-const cuid = require('@paralleldrive/cuid2').init({ length: 32 });
+require("dotenv").config();
+const fs = require("fs");
+const { Config } = require("./websocket/config.cjs");
+const { Connection } = require("./websocket/connection/index.cjs");
+const { Transport } = require("./websocket/transport/index.cjs");
+const { Dispatcher } = require("./dispatcher/index.cjs");
+const { WebsocketConnector } = require("./websocket/index.cjs");
+const JWE = require("./util/jwe/index.cjs");
+const fetch = require("node-fetch");
+const cuid = require("@paralleldrive/cuid2").init({ length: 32 });
 // TODO fetch with retry
 const handlePacketError = (packet, e, transport) => {
     if (!packet.cb()) {
-        console.dir({ msg: 'packet error', e, packet }, { depth: null });
+        console.dir({ msg: "packet error", e, packet }, { depth: null });
         return;
     }
-    transport.send(transport.newPacket({ c: packet.cb(), a: { error: '' + e } }));
+    transport.send(transport.newPacket({ c: packet.cb(), a: { error: "" + e } }));
 };
 const reply = (arg, packet, transport) => {
     if (!packet.cb()) {
-        console.dir({ msg: 'cannot reply to packet without cb', arg, packet }, { depth: null });
+        console.dir({ msg: "cannot reply to packet without cb", arg, packet }, { depth: null });
         return;
     }
     transport.send(transport.newPacket({ c: packet.cb(), a: { ...arg } }));
@@ -30,7 +30,7 @@ const unwrap = async (ret, options) => {
     if (options?.text)
         return await ret.text();
     if (options?.base64)
-        return (await ret.buffer()).toString('base64');
+        return (await ret.buffer()).toString("base64");
     return await ret.json();
 };
 class Fetcher {
@@ -57,13 +57,13 @@ class Fetcher {
         if (retries == null)
             retries = local.retry;
         try {
-            const theURL = `${baseUrl?.endsWith('/') ? baseUrl : baseUrl + '/'}${url}`.replace(/\/\/+/gi, '/');
+            const theURL = `${baseUrl?.endsWith("/") ? baseUrl : baseUrl + "/"}${url}`.replace(/\/\/+/gi, "/");
             await local.customize(options, args);
             const ret = await fetch(theURL, options);
             const status = await ret.status;
             if (status > 399) {
                 const text = await ret.text();
-                const e = new Error(status + ' ' + text);
+                const e = new Error(status + " " + text);
                 e.status = status;
                 throw e;
             }
@@ -92,14 +92,14 @@ class OAuthFetcher extends Fetcher {
             return oauth.accessToken();
         const refreshToken = oauth.refreshToken();
         if (!refreshToken)
-            throw new Error('have no access_token and no refresh_token');
+            throw new Error("have no access_token and no refresh_token");
         const ret = await oauth.obtainViaRefreshToken(oauth.refreshToken());
         if (ret.access_token) {
             oauth.update(ret.access_token, ret.refresh_token);
             return ret.access_token;
         }
         else {
-            throw new Error('could not obtain access token via refresh token');
+            throw new Error("could not obtain access token via refresh token");
         }
     }
     async onError(e, url, options, retries, args) {
@@ -107,7 +107,9 @@ class OAuthFetcher extends Fetcher {
         return new Promise((resolve, reject) => {
             setTimeout(async () => {
                 try {
-                    resolve(await local.fetch(url, options, retries, { forceTokenRefresh: e.status === 401 }));
+                    resolve(await local.fetch(url, options, retries, {
+                        forceTokenRefresh: e.status === 401,
+                    }));
                 }
                 catch (e) {
                     reject(e);
@@ -163,36 +165,36 @@ class Connector {
     async run() {
         var local = this;
         const makeMetrics = () => {
-            const metrics = require('prom-client');
+            const metrics = require("prom-client");
             const defaultLabels = {
                 service: local.name,
                 connectorId: local.id,
                 connectorVersion: local.version,
-                node: process.env.HOSTNAME || 'test',
+                node: process.env.HOSTNAME || "test",
             };
             metrics.register.setDefaultLabels(defaultLabels);
             metrics.collectDefaultMetrics();
             return metrics;
         };
         const makeMetricsServer = (metrics) => {
-            const app = require('express')();
-            app.get('/metrics', async (request, response, next) => {
+            const app = require("express")();
+            app.get("/metrics", async (request, response, next) => {
                 response.status(200);
-                response.set('Content-type', metrics.contentType);
+                response.set("Content-type", metrics.contentType);
                 response.send(await metrics.register.metrics());
                 response.end();
             });
             return app;
         };
-        makeMetricsServer(makeMetrics()).listen(4050, '0.0.0.0');
+        makeMetricsServer(makeMetrics()).listen(4050, "0.0.0.0");
         const { processPacket, start, introspect, configSchema } = this.dispatcher.build();
         const config = new Config({
             id: this.id,
             version: this.version,
             name: process.env.HOSTNAME || this.name,
             registrationToken: process.env.REGISTRATION_TOKEN,
-            endpoint: process.env.DEVICE_ENDPOINT || 'https://connect.aloma.io/',
-            wsEndpoint: process.env.WEBSOCKET_ENDPOINT || 'wss://transport.aloma.io/transport/',
+            endpoint: process.env.DEVICE_ENDPOINT || "https://connect.aloma.io/",
+            wsEndpoint: process.env.WEBSOCKET_ENDPOINT || "wss://transport.aloma.io/transport/",
             privateKey: process.env.PRIVATE_KEY,
             publicKey: process.env.PUBLIC_KEY,
             introspect,
@@ -205,15 +207,15 @@ class Connector {
             catch (e) {
                 const haveKey = !!process.env.PRIVATE_KEY;
                 const jwe = new JWE({});
-                var text = 'Please double check the env variables';
+                var text = "Please double check the env variables";
                 if (!haveKey) {
                     await jwe.newPair();
                     text =
-                        'fresh keys generated, set environment variables: \n\nPRIVATE_KEY: ' +
+                        "fresh keys generated, set environment variables: \n\nPRIVATE_KEY: " +
                             (await jwe.exportPrivateAsBase64()) +
-                            '\n\nPUBLIC_KEY: ' +
+                            "\n\nPUBLIC_KEY: " +
                             (await jwe.exportPublicAsBase64()) +
-                            '\n';
+                            "\n";
                 }
                 console.log(`
 Error: 
@@ -232,7 +234,7 @@ ${text}
                     const decrypted = {};
                     const fields = configSchema().fields;
                     const keys = Object.keys(secrets);
-                    const jwe = await config.validateKeys('RSA-OAEP-256');
+                    const jwe = await config.validateKeys("RSA-OAEP-256");
                     for (var i = 0; i < keys.length; ++i) {
                         const key = keys[i];
                         const value = secrets[key];
@@ -246,17 +248,22 @@ ${text}
                                 decrypted[key] = await jwe.decrypt(value, config.id());
                             }
                             catch (e) {
-                                console.log('failed to decrypt key', key, config.id(), e);
+                                console.log("failed to decrypt key", key, config.id(), e);
                             }
                         }
                     }
                     this.startOAuth = async function (args) {
                         if (!this._oauth)
-                            throw new Error('oauth not configured');
-                        const clientId = this._oauth.clientId || process.env.OAUTH_CLIENT_ID || decrypted.clientId;
+                            throw new Error("oauth not configured");
+                        const clientId = this._oauth.clientId ||
+                            process.env.OAUTH_CLIENT_ID ||
+                            decrypted.clientId;
                         if (!clientId)
-                            throw new Error('clientId not configured');
-                        const scopes = this._oauth.scope || process.env.OAUTH_SCOPE || decrypted.scope || '';
+                            throw new Error("clientId not configured");
+                        const scopes = this._oauth.scope ||
+                            process.env.OAUTH_SCOPE ||
+                            decrypted.scope ||
+                            "";
                         const useCodeChallenge = !!that._oauth.useCodeChallenge;
                         return {
                             url: this._oauth.authorizationURL
@@ -268,19 +275,23 @@ ${text}
                     this.finishOAuth = async function (arg) {
                         var that = this;
                         if (!this._oauth)
-                            throw new Error('oauth not configured');
+                            throw new Error("oauth not configured");
                         if (!this._oauth.tokenURL && !this._oauth.finishOAuth)
-                            throw new Error('need tokenURL or finishOAuth(arg)');
+                            throw new Error("need tokenURL or finishOAuth(arg)");
                         var data = null;
                         const doFinish = async () => {
                             if (!arg.code || !arg.redirectURI)
-                                throw new Error('need code and redirectUri');
-                            const clientId = that._oauth.clientId || process.env.OAUTH_CLIENT_ID || decrypted.clientId;
+                                throw new Error("need code and redirectUri");
+                            const clientId = that._oauth.clientId ||
+                                process.env.OAUTH_CLIENT_ID ||
+                                decrypted.clientId;
                             if (!clientId)
-                                throw new Error('clientId not configured');
-                            const clientSecret = that._oauth.clientSecret || process.env.OAUTH_CLIENT_SECRET || decrypted.clientSecret;
+                                throw new Error("clientId not configured");
+                            const clientSecret = that._oauth.clientSecret ||
+                                process.env.OAUTH_CLIENT_SECRET ||
+                                decrypted.clientSecret;
                             if (!clientSecret)
-                                throw new Error('clientSecret not configured');
+                                throw new Error("clientSecret not configured");
                             const additionalTokenArgs = that._oauth.additionalTokenArgs || {};
                             const useAuthHeader = !!that._oauth.useAuthHeader;
                             const useCodeChallenge = !!that._oauth.useCodeChallenge;
@@ -293,8 +304,8 @@ ${text}
                                 body.code_verifier = arg.codeVerifier;
                             }
                             let headers = {
-                                'Content-Type': 'application/x-www-form-urlencoded;charset=UTF-8',
-                                Accept: 'application/json',
+                                "Content-Type": "application/x-www-form-urlencoded;charset=UTF-8",
+                                Accept: "application/json",
                             };
                             if (useAuthHeader) {
                                 headers = {
@@ -310,7 +321,7 @@ ${text}
                                 };
                             }
                             const response = await fetch(that._oauth.tokenURL, {
-                                method: 'POST',
+                                method: "POST",
                                 body: new URLSearchParams(body),
                                 headers,
                             });
@@ -319,17 +330,17 @@ ${text}
                             if (status === 200) {
                                 const ret = JSON.parse(text);
                                 if (ret.error) {
-                                    throw new Error(`${status} ${ret.error} ${ret.error_description || ''}`);
+                                    throw new Error(`${status} ${ret.error} ${ret.error_description || ""}`);
                                 }
                                 else if (ret.access_token) {
                                     return { ...ret };
                                 }
                                 else {
-                                    throw new Error(status + ' response has no access_token - ' + text);
+                                    throw new Error(status + " response has no access_token - " + text);
                                 }
                             }
                             else {
-                                throw new Error(status + ' ' + text);
+                                throw new Error(status + " " + text);
                             }
                         };
                         if (this._oauth.finishOAuth) {
@@ -342,26 +353,30 @@ ${text}
                         else {
                             data = await doFinish();
                         }
-                        const jwe = await config.validateKeys('RSA-OAEP-256');
-                        return { value: await jwe.encrypt(data, 'none', config.id()) };
+                        const jwe = await config.validateKeys("RSA-OAEP-256");
+                        return { value: await jwe.encrypt(data, "none", config.id()) };
                     };
                     const saveOAuthResult = async (what) => {
-                        const jwe = await config.validateKeys('RSA-OAEP-256');
+                        const jwe = await config.validateKeys("RSA-OAEP-256");
                         const packet = transport.newPacket({});
-                        packet.method('connector.config-update');
+                        packet.method("connector.config-update");
                         packet.args({
-                            value: await jwe.encrypt(what, 'none', config.id()),
+                            value: await jwe.encrypt(what, "none", config.id()),
                         });
                         transport.send(packet);
                     };
                     const that = this;
                     const getRefreshToken = async (refreshToken) => {
-                        const clientId = that._oauth.clientId || process.env.OAUTH_CLIENT_ID || decrypted.clientId;
+                        const clientId = that._oauth.clientId ||
+                            process.env.OAUTH_CLIENT_ID ||
+                            decrypted.clientId;
                         if (!clientId)
-                            throw new Error('clientId not configured');
-                        const clientSecret = that._oauth.clientSecret || process.env.OAUTH_CLIENT_SECRET || decrypted.clientSecret;
+                            throw new Error("clientId not configured");
+                        const clientSecret = that._oauth.clientSecret ||
+                            process.env.OAUTH_CLIENT_SECRET ||
+                            decrypted.clientSecret;
                         if (!clientSecret)
-                            throw new Error('clientSecret not configured');
+                            throw new Error("clientSecret not configured");
                         const useAuthHeader = !!that._oauth.useAuthHeader;
                         let headers = {};
                         if (useAuthHeader) {
@@ -371,16 +386,16 @@ ${text}
                             };
                         }
                         const response = await fetch(that._oauth.tokenURL, {
-                            method: 'POST',
+                            method: "POST",
                             body: new URLSearchParams({
-                                grant_type: 'refresh_token',
+                                grant_type: "refresh_token",
                                 refresh_token: refreshToken,
                                 client_id: clientId,
                                 client_secret: clientSecret,
                             }),
                             headers: {
-                                'Content-Type': 'application/x-www-form-urlencoded;charset=UTF-8',
-                                Accept: 'application/json',
+                                "Content-Type": "application/x-www-form-urlencoded;charset=UTF-8",
+                                Accept: "application/json",
                                 ...headers,
                             },
                         });
@@ -390,7 +405,7 @@ ${text}
                             return JSON.parse(text);
                         }
                         else {
-                            throw new Error('could not get refresh token ' + status + ' ' + text);
+                            throw new Error("could not get refresh token " + status + " " + text);
                         }
                     };
                     const theOAuth = decrypted.oauthResult
@@ -399,11 +414,11 @@ ${text}
                     start({
                         config: decrypted,
                         oauth: theOAuth,
-                        getClient: (arg) => (theOAuth ? theOAuth.getClient(arg) : new Fetcher({ ...arg })),
+                        getClient: (arg) => theOAuth ? theOAuth.getClient(arg) : new Fetcher({ ...arg }),
                         newTask: (name, data) => {
                             return new Promise((resolve, reject) => {
                                 const packet = transport.newPacket({}, (ret) => (ret?.error ? reject(ret.error) : resolve(ret)), `_req-${cuid()}`);
-                                packet.method('connector.task.new');
+                                packet.method("connector.task.new");
                                 packet.args({
                                     name,
                                     a: data,
@@ -414,7 +429,7 @@ ${text}
                         updateTask: (id, data) => {
                             return new Promise((resolve, reject) => {
                                 const packet = transport.newPacket({}, (ret) => (ret?.error ? reject(ret.error) : resolve(ret)), `_req-${cuid()}`);
-                                packet.method('connector.task.update');
+                                packet.method("connector.task.update");
                                 packet.args({
                                     id,
                                     a: data,
@@ -447,14 +462,14 @@ ${text}
             });
             process.exit(0);
         };
-        process.on('uncaughtException', (e) => {
+        process.on("uncaughtException", (e) => {
             console.log(e);
         });
-        process.on('unhandledRejection', (e) => {
+        process.on("unhandledRejection", (e) => {
             console.log(e);
         });
-        process.on('SIGTERM', term);
-        process.on('SIGINT', term);
+        process.on("SIGTERM", term);
+        process.on("SIGINT", term);
         await server.start();
     }
 }

package/build/internal/util/jwe/cli.cjs

@@ -1,12 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const JWE = require('./index');
+const JWE = require("./index");
 const main = async () => {
     const jwe = new JWE({});
     await jwe.newPair();
-    console.log('private key');
+    console.log("private key");
     console.log(await jwe.exportPrivateAsBase64());
-    console.log('public key');
+    console.log("public key");
     console.log(await jwe.exportPublicAsBase64());
 };
 setTimeout(() => null, 100);

package/build/internal/util/jwe/index.cjs

@@ -1,9 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const jose = require('jose');
+const jose = require("jose");
 class JWE {
-    constructor({ algorithm = 'PS256' }) {
-        this.issuer = 'home.aloma.io';
+    constructor({ algorithm = "PS256" }) {
+        this.issuer = "home.aloma.io";
         this.algorithm = algorithm;
     }
     async newPair() {
@@ -17,11 +17,11 @@ class JWE {
     }
     async exportPrivateAsBase64() {
         const pair = await this.exportPair();
-        return Buffer.from(pair.privateKey).toString('base64');
+        return Buffer.from(pair.privateKey).toString("base64");
     }
     async exportPublicAsBase64() {
         const pair = await this.exportPair();
-        return Buffer.from(pair.publicKey).toString('base64');
+        return Buffer.from(pair.publicKey).toString("base64");
     }
     async importPair({ publicKey, privateKey, algorithm }) {
         this.pair = {
@@ -31,18 +31,18 @@ class JWE {
     }
     async importBase64Pair({ publicKey, privateKey, algorithm }) {
         this.importPair({
-            publicKey: Buffer.from(publicKey, 'base64').toString(),
-            privateKey: Buffer.from(privateKey, 'base64').toString(),
+            publicKey: Buffer.from(publicKey, "base64").toString(),
+            privateKey: Buffer.from(privateKey, "base64").toString(),
             algorithm,
         });
     }
-    async encrypt(what, expiration = '7d', audience, algorithm = 'RSA-OAEP-256') {
+    async encrypt(what, expiration = "7d", audience, algorithm = "RSA-OAEP-256") {
         const item = new jose.EncryptJWT({ _data: { ...what } })
-            .setProtectedHeader({ alg: algorithm, enc: 'A256GCM' })
+            .setProtectedHeader({ alg: algorithm, enc: "A256GCM" })
             .setIssuedAt()
             .setIssuer(this.issuer)
             .setAudience(audience);
-        if (expiration && expiration !== 'none')
+        if (expiration && expiration !== "none")
             item.setExpirationTime(expiration);
         return await item.encrypt(this.pair.publicKey);
     }

package/build/internal/websocket/config.cjs

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const C = require('./connection/constants.cjs');
-const JWE = require('../util/jwe/index.cjs');
+const C = require("./connection/constants.cjs");
+const JWE = require("../util/jwe/index.cjs");
 class Config {
     constructor({ registrationToken, version, name, id, endpoint, wsEndpoint, privateKey, publicKey, introspect, configSchema, }) {
         this._token = null;
@@ -18,17 +18,17 @@ class Config {
         this._introspect = introspect;
         this._configSchema = configSchema;
         if (!registrationToken)
-            throw new Error('empty registration token (set env.REGISTRATION_TOKEN)');
+            throw new Error("empty registration token (set env.REGISTRATION_TOKEN)");
         if (!endpoint)
-            throw new Error('empty endpoint (set env.DEVICE_ENDPOINT)');
+            throw new Error("empty endpoint (set env.DEVICE_ENDPOINT)");
         if (!wsEndpoint)
-            throw new Error('empty registration token (set env.WEBSOCKET_ENDPOINT)');
+            throw new Error("empty registration token (set env.WEBSOCKET_ENDPOINT)");
         if (!this._id || !this._version)
-            throw new Error('need connector id and version');
+            throw new Error("need connector id and version");
     }
     async validateKeys(algorithm) {
         if (!this._privateKey || !this._publicKey)
-            throw new Error('need private and public key');
+            throw new Error("need private and public key");
         await this._jwe.importBase64Pair({
             publicKey: this._publicKey,
             privateKey: this._privateKey,

package/build/internal/websocket/connection/constants.cjs

@@ -1,11 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const AUTHORIZATION = 'Authorization';
+const AUTHORIZATION = "Authorization";
 module.exports = {
     augmentRequest: (what, config) => {
         what.headers = {
             ...what.headers,
-            'User-Agent': config.id() + '/' + config.version(),
+            "User-Agent": config.id() + "/" + config.version(),
         };
         what.headers[AUTHORIZATION] = `Connector ${config.token()}`;
         return what;
@@ -13,7 +13,7 @@ module.exports = {
     augmentRegistration: (what, config) => {
         what.headers = {
             ...what.headers,
-            'User-Agent': config.id() + '/' + config.version(),
+            "User-Agent": config.id() + "/" + config.version(),
         };
         what.headers[AUTHORIZATION] = `Connector ${config.registrationToken()}`;
         return what;

package/build/internal/websocket/connection/index.cjs

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const fetch = require('node-fetch');
-const { Registration } = require('./registration.cjs');
-const C = require('./constants.cjs');
+const fetch = require("node-fetch");
+const { Registration } = require("./registration.cjs");
+const C = require("./constants.cjs");
 class Connection {
     constructor({ config, onStart }) {
         this.config = config;
@@ -11,10 +11,10 @@ class Connection {
     async start() {
         var local = this, config = local.config;
         try {
-            const response = await fetch(config.url() + 'connect', C.augmentRequest({
-                method: 'POST',
+            const response = await fetch(config.url() + "connect", C.augmentRequest({
+                method: "POST",
                 body: JSON.stringify({}),
-                headers: { 'Content-Type': 'application/json' },
+                headers: { "Content-Type": "application/json" },
             }, config));
             if (response.status === 401) {
                 config.setToken(await new Registration(local.config).run());
@@ -39,10 +39,10 @@ class Connection {
     }
     async close() {
         try {
-            await fetch(this.config.url() + 'disconnect', C.augmentRequest({
-                method: 'POST',
+            await fetch(this.config.url() + "disconnect", C.augmentRequest({
+                method: "POST",
                 body: JSON.stringify({}),
-                headers: { 'Content-Type': 'application/json' },
+                headers: { "Content-Type": "application/json" },
             }, this.config));
         }
         catch (e) {

package/build/internal/websocket/connection/registration.cjs

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const fetch = require('node-fetch');
-const C = require('./constants.cjs');
+const fetch = require("node-fetch");
+const C = require("./constants.cjs");
 class Registration {
     constructor(config) {
         this.config = config;
@@ -11,21 +11,21 @@ class Registration {
         const config = this.config;
         const configSchema = config.configSchema();
         const intro = await config.introspect();
-        const response = await fetch(config.url() + 'register', C.augmentRegistration({
-            method: 'POST',
+        const response = await fetch(config.url() + "register", C.augmentRegistration({
+            method: "POST",
             body: JSON.stringify({
-                deployment: process.env.DEPLOYMENT || '',
+                deployment: process.env.DEPLOYMENT || "",
                 name: config.name(),
                 version: config.version(),
                 id: config.id(),
                 publicKey: config.publicKey(),
                 schema: { configSchema, introspect: intro },
             }),
-            headers: { 'Content-Type': 'application/json' },
+            headers: { "Content-Type": "application/json" },
         }, config));
         if (response.status === 200)
             return (await response.json()).key;
-        throw new Error('authentication failed');
+        throw new Error("authentication failed");
     }
 }
 module.exports = { Registration };

package/build/internal/websocket/index.cjs

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const WebSocket = require('ws');
-const { Connection } = require('./connection/index.cjs');
-const { Transport } = require('./transport/index.cjs');
+const WebSocket = require("ws");
+const { Connection } = require("./connection/index.cjs");
+const { Transport } = require("./transport/index.cjs");
 class WebsocketConnector {
     constructor({ config, onMessage, onConnect }) {
         var local = this;

package/build/internal/websocket/transport/durable.cjs

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const WebSocket = require('ws');
+const WebSocket = require("ws");
 class DurableWebsocket {
     constructor({ endpoint, secret, onConnect, onMessage }) {
         this.endpoint = endpoint;
@@ -28,7 +28,7 @@ class DurableWebsocket {
             rejectUnauthorized: false,
             headers: { Authorization: `Bearer ${local.secret}` },
         }));
-        ws.on('open', () => {
+        ws.on("open", () => {
             local.connecting = false;
             local.fails = 0;
             var item;
@@ -37,15 +37,15 @@ class DurableWebsocket {
             }
             local.onConnect(local);
         });
-        ws.on('message', (message) => {
+        ws.on("message", (message) => {
             setImmediate(() => local.onMessage(JSON.parse(message)));
         });
-        ws.on('error', (message) => {
+        ws.on("error", (message) => {
             if (local.fails > 50)
-                console.log('error:', message.message);
+                console.log("error:", message.message);
             ++local.fails;
         });
-        ws.on('close', (message) => {
+        ws.on("close", (message) => {
             local.connecting = false;
             if (!local.closed)
                 setTimeout(() => local.start(), 5000);

package/build/internal/websocket/transport/index.cjs

@@ -1,11 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const fetch = require('node-fetch');
-const C = require('../connection/constants.cjs');
-const cuid = require('@paralleldrive/cuid2').init({ length: 32 });
-const { DurableWebsocket } = require('./durable.cjs');
-const WebSocket = require('ws');
-const { Packet, Callback } = require('./packet.cjs');
+const fetch = require("node-fetch");
+const C = require("../connection/constants.cjs");
+const cuid = require("@paralleldrive/cuid2").init({ length: 32 });
+const { DurableWebsocket } = require("./durable.cjs");
+const WebSocket = require("ws");
+const { Packet, Callback } = require("./packet.cjs");
 const cleanInterval = 45 * 1000;
 const pingInterval = 30 * 1000;
 class Transport {
@@ -38,7 +38,7 @@ class Transport {
             local.ws.send(JSON.stringify({ p: packets }));
         }
         catch (e) {
-            console.log('could not send packets ', e);
+            console.log("could not send packets ", e);
             packets.forEach((packet) => local.packets.unshift(packet));
         }
     }
@@ -48,20 +48,20 @@ class Transport {
             return;
         local.close();
         this.running = true;
-        const ws = (local.ws = new WebSocket(config.wsUrl(), ['connector'], C.augmentRequest({ headers: {} }, config)));
-        ws.on('open', () => {
-            console.log('websocket connected');
+        const ws = (local.ws = new WebSocket(config.wsUrl(), ["connector"], C.augmentRequest({ headers: {} }, config)));
+        ws.on("open", () => {
+            console.log("websocket connected");
             local.connected = true;
             local.pinger = setInterval(() => ws.ping(() => null), pingInterval);
             local.onConnect(local);
         });
-        ws.on('message', (message) => {
+        ws.on("message", (message) => {
             setTimeout(() => local.onMessages(JSON.parse(message)), 0);
         });
-        ws.on('error', (message) => {
-            console.log('error:', message);
+        ws.on("error", (message) => {
+            console.log("error:", message);
         });
-        ws.on('close', (message) => {
+        ws.on("close", (message) => {
             local.connected = false;
             clearInterval(local.pinger);
             if (local.running)
@@ -92,7 +92,7 @@ class Transport {
                 this.callbacks[packet.cb()].cb(packet.args());
             }
             catch (e) {
-                console.log('error processing packet', e, packet);
+                console.log("error processing packet", e, packet);
             }
             finally {
                 delete this.callbacks[packet.cb()];
@@ -117,12 +117,12 @@ class Transport {
             if (!cb)
                 return;
             if (cb.created < then) {
-                console.log('callback timeout', key);
+                console.log("callback timeout", key);
                 try {
-                    cb.cb({ error: 'timeout' });
+                    cb.cb({ error: "timeout" });
                 }
                 catch (e) {
-                    console.log('error while callback', key, cb, e);
+                    console.log("error while callback", key, cb, e);
                 }
                 delete local.callbacks[key];
             }

package/build/internal/websocket/transport/packet.cjs

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const fetch = require('node-fetch');
-const cuid = require('@paralleldrive/cuid2').init({ length: 32 });
+const fetch = require("node-fetch");
+const cuid = require("@paralleldrive/cuid2").init({ length: 32 });
 class Packet {
     constructor(data = {}) {
         this.data = data;

package/build/internal/websocket/transport/processor.cjs

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const { Packet, Callback } = require('./packet.cjs');
+const { Packet, Callback } = require("./packet.cjs");
 class Processor {
     constructor({ transport, processPacket }) {
         var local = this;
@@ -33,24 +33,24 @@ class Processor {
                 callbacks[packet.cb()](packet.args());
             }
             catch (e) {
-                console.log('error in callback', callbacks[packet.cb()], packet);
+                console.log("error in callback", callbacks[packet.cb()], packet);
             }
             delete local.transport.callbacks[packet.cb()];
         }
         else if (packet.event()) {
-            console.log('handle event packet', packet);
+            console.log("handle event packet", packet);
         }
         else {
             try {
                 const result = await local._processPacket(packet);
                 const reply = local.transport.newPacket({});
-                reply.method('connector.reply');
+                reply.method("connector.reply");
                 reply.cb(original.cb());
                 reply.args({ ...result });
                 local.transport.send(reply);
             }
             catch (e) {
-                console.log('error processing packet', e, packet);
+                console.log("error processing packet", e, packet);
             }
         }
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aloma.io/integration-sdk",
-  "version": "3.0.2",
+  "version": "3.0.3",
   "description": "",
   "author": "aloma.io",
   "license": "Apache-2.0",