@aloma.io/integration-sdk 3.7.49 → 3.7.50

package/build/internal/connector/config.d.mts

@@ -0,0 +1,9 @@
+import { Config } from "../websocket/config.mjs";
+export declare const makeConfig: ({ id, version, name, introspect, configSchema, icon }: {
+    id: any;
+    version: any;
+    name: any;
+    introspect: any;
+    configSchema: any;
+    icon: any;
+}) => Promise<Config>;

package/build/internal/connector/config.mjs

@@ -0,0 +1,50 @@
+import JWE from "../util/jwe/index.mjs";
+import { Config } from "../websocket/config.mjs";
+export const makeConfig = async ({ id, version, name, introspect, configSchema, icon }) => {
+    const config = new Config({
+        id: id,
+        version: version,
+        name: process.env.HOSTNAME || name,
+        registrationToken: process.env.REGISTRATION_TOKEN,
+        endpoint: process.env.DEVICE_ENDPOINT || "https://connect.aloma.io/",
+        wsEndpoint: process.env.WEBSOCKET_ENDPOINT || "wss://connect.aloma.io/transport/",
+        privateKey: process.env.PRIVATE_KEY,
+        publicKey: process.env.PUBLIC_KEY,
+        introspect,
+        configSchema,
+        icon: icon,
+    });
+    if (Object.keys(configSchema().fields).length) {
+        try {
+            await config.validateKeys();
+        }
+        catch (e) {
+            const haveKey = !!process.env.PRIVATE_KEY;
+            const jwe = new JWE({});
+            var text = "Please double check the env variables";
+            if (!haveKey) {
+                await jwe.newPair();
+                text =
+                    "fresh keys generated, set environment variables: \n\nPRIVATE_KEY: " +
+                        (await jwe.exportPrivateAsBase64()) +
+                        "\n\nPUBLIC_KEY: " +
+                        (await jwe.exportPublicAsBase64()) +
+                        "\n";
+            }
+            console.log(`
+Error:
+
+public (env.PUBLIC_KEY) and private key (env.PRIVATE_KEY) could not be loaded.
+
+${text}
+      `);
+            await new Promise((resolve) => {
+                setTimeout(() => {
+                    resolve(null);
+                }, 2 * 60 * 1000);
+            });
+            throw new Error('could not start');
+        }
+    }
+    return config;
+};

package/build/internal/connector/index.d.mts

@@ -0,0 +1,16 @@
+import { Dispatcher } from "../dispatcher/index.mjs";
+export declare class Connector {
+    id: any;
+    version: any;
+    name: any;
+    icon: any;
+    dispatcher?: Dispatcher;
+    constructor({ version, id, name, icon }: {
+        version: any;
+        id: any;
+        name: any;
+        icon: any;
+    });
+    configure(): Dispatcher;
+    run(): Promise<void>;
+}

package/build/internal/connector/index.mjs

@@ -0,0 +1,39 @@
+import { Dispatcher } from "../dispatcher/index.mjs";
+import { makeConfig } from "./config.mjs";
+import { makeMetrics } from "./metrics.mjs";
+import { makeServer } from "./server/index.mjs";
+export class Connector {
+    id;
+    version;
+    name;
+    icon;
+    dispatcher;
+    constructor({ version, id, name, icon }) {
+        this.id = id;
+        this.version = version;
+        this.name = name;
+        this.icon = icon;
+    }
+    configure() {
+        return (this.dispatcher = new Dispatcher());
+    }
+    async run() {
+        console.log(`Running ${this.name} (${this.version})`);
+        const { processPacket, start, introspect, configSchema } = this.dispatcher.build();
+        const config = await makeConfig({
+            id: this.id,
+            version: this.version,
+            name: this.name,
+            introspect,
+            configSchema,
+            icon: this.icon,
+        });
+        await makeMetrics({
+            id: this.id,
+            name: this.name,
+            version: this.version,
+        });
+        const server = await makeServer({ config, configSchema, start, processPacket, dispatcher: this.dispatcher });
+        await server.start();
+    }
+}

package/build/internal/connector/metrics.d.mts

@@ -0,0 +1,5 @@
+export declare const makeMetrics: ({ id, name, version }: {
+    id: any;
+    name: any;
+    version: any;
+}) => Promise<void>;

package/build/internal/connector/metrics.mjs

@@ -0,0 +1,27 @@
+import express from "express";
+import PromClient from "prom-client";
+export const makeMetrics = async ({ id, name, version }) => {
+    const newMetrics = () => {
+        const metrics = PromClient;
+        const defaultLabels = {
+            service: name,
+            connectorId: id,
+            connectorVersion: version,
+            node: process.env.HOSTNAME || "test",
+        };
+        metrics.register.setDefaultLabels(defaultLabels);
+        metrics.collectDefaultMetrics();
+        return metrics;
+    };
+    const makeMetricsServer = (metrics) => {
+        const app = express();
+        app.get("/metrics", async (request, response, next) => {
+            response.status(200);
+            response.set("Content-type", metrics.contentType);
+            response.send(await metrics.register.metrics());
+            response.end();
+        });
+        return app;
+    };
+    makeMetricsServer(newMetrics()).listen(4050, "0.0.0.0");
+};

package/build/internal/connector/server/index.d.mts

@@ -0,0 +1,10 @@
+import Dispatcher from "../../dispatcher/index.mjs";
+import { Config } from "../../websocket/config.mjs";
+import { WebsocketConnector } from "../../websocket/index.mjs";
+export declare const makeServer: ({ config, configSchema, start, processPacket, dispatcher }: {
+    config: Config;
+    configSchema: any;
+    start: any;
+    processPacket: any;
+    dispatcher: Dispatcher;
+}) => Promise<WebsocketConnector>;

package/build/internal/connector/server/index.mjs

@@ -0,0 +1,29 @@
+import { WebsocketConnector } from "../../websocket/index.mjs";
+import { onConnect } from "./on-connect/index.mjs";
+import { onMessage } from "./on-message.mjs";
+export const makeServer = async ({ config, configSchema, start, processPacket, dispatcher }) => {
+    const server = new WebsocketConnector({
+        config,
+        onConnect: onConnect({ config, configSchema, dispatcher, start }),
+        onMessage: onMessage(processPacket)
+    });
+    const term = async () => {
+        await server.leaving();
+        await new Promise((resolve) => {
+            setTimeout(async () => {
+                await server.close();
+                resolve(null);
+            }, 10000);
+        });
+        process.exit(0);
+    };
+    process.on("uncaughtException", (e) => {
+        console.log(e);
+    });
+    process.on("unhandledRejection", (e) => {
+        console.log(e);
+    });
+    process.on("SIGTERM", term);
+    process.on("SIGINT", term);
+    return server;
+};

package/build/internal/connector/server/on-connect/decrypt-config.d.mts

@@ -0,0 +1,5 @@
+export declare const decryptConfig: ({ configSchema, config, secrets }: {
+    configSchema: any;
+    config: any;
+    secrets: any;
+}) => Promise<any>;

package/build/internal/connector/server/on-connect/decrypt-config.mjs

@@ -0,0 +1,24 @@
+export const decryptConfig = async ({ configSchema, config, secrets }) => {
+    const decrypted = {};
+    const fields = configSchema().fields;
+    const keys = Object.keys(secrets);
+    const jwe = await config.validateKeys("RSA-OAEP-256");
+    for (var i = 0; i < keys.length; ++i) {
+        const key = keys[i];
+        const value = secrets[key];
+        if (!value)
+            continue;
+        if (fields[key]?.plain || ["endpointUrl"].includes(key)) {
+            decrypted[key] = value;
+        }
+        else {
+            try {
+                decrypted[key] = await jwe.decrypt(value, config.id());
+            }
+            catch (e) {
+                console.log("failed to decrypt key", key, config.id(), e);
+            }
+        }
+    }
+    return decrypted;
+};

package/build/internal/connector/server/on-connect/finish-oauth.d.mts

@@ -0,0 +1,9 @@
+import Dispatcher from "../../../dispatcher/index.mjs";
+import { Config } from "../../../websocket/config.mjs";
+import { WebsocketConnector } from "../../../websocket/index.mjs";
+export declare const patchFinishOAuth: ({ dispatcher, decrypted, config, transport }: {
+    dispatcher: Dispatcher;
+    decrypted: any;
+    config: Config;
+    transport: WebsocketConnector;
+}) => Promise<void>;

package/build/internal/connector/server/on-connect/finish-oauth.mjs

@@ -0,0 +1,90 @@
+export const patchFinishOAuth = async ({ dispatcher, decrypted, config, transport }) => {
+    dispatcher.finishOAuth = async function (arg) {
+        const tokenURL = process.env.OAUTH_TOKEN_URL ||
+            decrypted.tokenURL ||
+            dispatcher._oauth.tokenURL;
+        if (!dispatcher._oauth)
+            throw new Error("oauth not configured");
+        if (!tokenURL && !dispatcher._oauth.finishOAuth)
+            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 = decrypted.clientId ||
+                process.env.OAUTH_CLIENT_ID ||
+                dispatcher._oauth.clientId;
+            if (!clientId)
+                throw new Error("clientId not configured");
+            const clientSecret = decrypted.clientSecret ||
+                process.env.OAUTH_CLIENT_SECRET ||
+                dispatcher._oauth.clientSecret;
+            if (!clientSecret)
+                throw new Error("clientSecret not configured");
+            const additionalTokenArgs = dispatcher._oauth.additionalTokenArgs || {};
+            const useAuthHeader = !!dispatcher._oauth.useAuthHeader;
+            const useCodeChallenge = !!dispatcher._oauth.useCodeChallenge;
+            let body = {
+                grant_type: "authorization_code",
+                ...additionalTokenArgs,
+                code: arg.code,
+                redirect_uri: arg.redirectURI,
+            };
+            if (useCodeChallenge) {
+                body.code_verifier = arg.codeVerifier;
+            }
+            let headers = {
+                "Content-Type": "application/x-www-form-urlencoded;charset=UTF-8",
+                Accept: "application/json",
+            };
+            if (useAuthHeader) {
+                headers = {
+                    ...headers,
+                    Authorization: `Basic ${btoa(`${clientId}:${clientSecret}`)}`,
+                };
+            }
+            else {
+                body = {
+                    ...body,
+                    client_id: clientId,
+                    client_secret: clientSecret,
+                };
+            }
+            const response = await fetch(tokenURL, {
+                method: "POST",
+                body: new URLSearchParams(body),
+                headers,
+                signal: AbortSignal.timeout(60 * 1000),
+            });
+            const status = await response.status;
+            const text = await response.text();
+            if (status === 200) {
+                const ret = JSON.parse(text);
+                if (ret.error) {
+                    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);
+                }
+            }
+            else {
+                throw new Error(status + " " + text);
+            }
+        };
+        if (dispatcher._oauth.finishOAuth) {
+            data = await dispatcher._oauth.finishOAuth({
+                arg,
+                doFinish,
+                transport,
+            });
+        }
+        else {
+            data = await doFinish();
+        }
+        const jwe = await config.validateKeys("RSA-OAEP-256");
+        return { value: await jwe.encrypt(data, "none", config.id()) };
+    };
+};

package/build/internal/connector/server/on-connect/index.d.mts

@@ -0,0 +1,8 @@
+import Dispatcher from "../../../dispatcher/index.mjs";
+import { Config } from "../../../websocket/config.mjs";
+export declare const onConnect: ({ dispatcher, configSchema, config, start }: {
+    config: Config;
+    configSchema: any;
+    start: any;
+    dispatcher: Dispatcher;
+}) => (transport: any) => Promise<void>;

package/build/internal/connector/server/on-connect/index.mjs

@@ -0,0 +1,95 @@
+import { init } from "@paralleldrive/cuid2";
+import Fetcher from "../../../fetcher/fetcher.mjs";
+import { decryptConfig } from "./decrypt-config.mjs";
+import { patchFinishOAuth } from "./finish-oauth.mjs";
+import { makeOAuth } from "./make-oauth.mjs";
+import { patchStartOAuth } from "./start-oauth.mjs";
+const cuid = init({ length: 32 });
+export const onConnect = ({ dispatcher, configSchema, config, start }) => {
+    return async (transport) => {
+        dispatcher.onConfig = async function (secrets) {
+            const decrypted = await decryptConfig({ configSchema, secrets, config });
+            await patchStartOAuth({ dispatcher, decrypted });
+            await patchFinishOAuth({ dispatcher, decrypted, config, transport });
+            const theOAuth = await makeOAuth({ config, transport, decrypted, dispatcher });
+            const getBlob = (id) => {
+                return new Promise((resolve, reject) => {
+                    const packet = transport.newPacket({}, (ret) => (ret?.error ? reject(ret.error) : resolve(ret)), `_req-${cuid()}`);
+                    packet.method("connector.blob.get");
+                    packet.args({
+                        id,
+                    });
+                    transport.send(packet);
+                });
+            };
+            const getBlobContent = (id) => {
+                return new Promise((resolve, reject) => {
+                    const packet = transport.newPacket({}, (ret) => ret?.error ? reject(ret.error) : resolve(ret?.content), `_req-${cuid()}`);
+                    packet.method("connector.blob.get-content");
+                    packet.args({
+                        id,
+                    });
+                    transport.send(packet);
+                });
+            };
+            const createBlob = (args = {}) => {
+                return new Promise((resolve, reject) => {
+                    const packet = transport.newPacket({}, (ret) => (ret?.error ? reject(ret.error) : resolve(ret?.id)), `_req-${cuid()}`);
+                    packet.method("connector.blob.create");
+                    packet.args(args);
+                    transport.send(packet);
+                });
+            };
+            let oauthClient;
+            start({
+                config: decrypted,
+                oauth: theOAuth,
+                getBlob,
+                getBlobContent,
+                createBlob,
+                healthCheck: async (controller) => {
+                    let result = { ok: true, error: null };
+                    try {
+                        if (oauthClient) {
+                            await oauthClient.__healthCheck();
+                        }
+                        await controller.__healthCheck();
+                    }
+                    catch (e) {
+                        result.ok = false;
+                        result.error = e.message;
+                    }
+                    const packet = transport.newPacket({});
+                    packet.method("connector.health.check");
+                    packet.args(result);
+                    transport.send(packet);
+                },
+                getClient: (arg) => theOAuth
+                    ? (oauthClient = 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.args({
+                            name,
+                            a: data,
+                        });
+                        transport.send(packet);
+                    });
+                },
+                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.args({
+                            id,
+                            a: data,
+                        });
+                        transport.send(packet);
+                    });
+                },
+            });
+        };
+    };
+};

package/build/internal/connector/server/on-connect/make-oauth.d.mts

@@ -0,0 +1,9 @@
+import Dispatcher from "../../../dispatcher/index.mjs";
+import { OAuth } from "../../../fetcher/oauth-fetcher.mjs";
+import { Config } from "../../../websocket/config.mjs";
+export declare const makeOAuth: ({ config, transport, decrypted, dispatcher }: {
+    config: Config;
+    transport: any;
+    decrypted: any;
+    dispatcher: Dispatcher;
+}) => Promise<OAuth | null>;

package/build/internal/connector/server/on-connect/make-oauth.mjs

@@ -0,0 +1,77 @@
+import { OAuth } from "../../../fetcher/oauth-fetcher.mjs";
+export const makeOAuth = async ({ config, transport, decrypted, dispatcher }) => {
+    const saveOAuthResult = async (what) => {
+        const jwe = await config.validateKeys("RSA-OAEP-256");
+        const value = await jwe.encrypt(what, "none", config.id());
+        const packet = transport.newPacket({});
+        packet.method("connector.config-update");
+        packet.args({
+            value,
+        });
+        transport.send(packet);
+    };
+    const getRefreshToken = async (refreshToken) => {
+        const tokenURL = process.env.OAUTH_TOKEN_URL ||
+            decrypted.tokenURL ||
+            dispatcher._oauth.tokenURL;
+        const clientId = decrypted.clientId ||
+            process.env.OAUTH_CLIENT_ID ||
+            dispatcher._oauth.clientId;
+        if (!clientId)
+            throw new Error("clientId not configured");
+        const clientSecret = decrypted.clientSecret ||
+            process.env.OAUTH_CLIENT_SECRET ||
+            dispatcher._oauth.clientSecret;
+        if (!clientSecret)
+            throw new Error("clientSecret not configured");
+        const useAuthHeader = !!dispatcher._oauth.useAuthHeader;
+        let headers = {};
+        if (useAuthHeader) {
+            headers = {
+                ...headers,
+                Authorization: `Basic ${btoa(`${clientId}:${clientSecret}`)}`,
+            };
+        }
+        const response = await fetch(tokenURL, {
+            method: "POST",
+            body: new URLSearchParams({
+                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",
+                ...headers,
+            },
+            signal: AbortSignal.timeout(60 * 1000),
+        });
+        const status = await response.status;
+        const text = await response.text();
+        if (status === 200) {
+            return JSON.parse(text);
+        }
+        else {
+            throw new Error("could not get refresh token " + status + " " + text);
+        }
+    };
+    const theOAuth = dispatcher._oauth
+        ? new OAuth(decrypted.oauthResult, saveOAuthResult, getRefreshToken)
+        : null;
+    if (theOAuth) {
+        clearInterval(dispatcher._refreshOAuthToken);
+        if (!(dispatcher._oauth.noPeriodicTokenRefresh === false)) {
+            dispatcher._refreshOAuthToken = setInterval(async () => {
+                try {
+                    console.log("refreshing oauth token");
+                    await theOAuth.periodicRefresh();
+                }
+                catch (e) {
+                    console.log("periodic refresh", e);
+                }
+            }, dispatcher._oauth.tokenRefreshPeriod || 4 * 60 * 60 * 15000);
+        }
+    }
+    return theOAuth;
+};

package/build/internal/connector/server/on-connect/start-oauth.d.mts

@@ -0,0 +1,4 @@
+export declare const patchStartOAuth: ({ dispatcher, decrypted }: {
+    dispatcher: any;
+    decrypted: any;
+}) => Promise<void>;

package/build/internal/connector/server/on-connect/start-oauth.mjs

@@ -0,0 +1,27 @@
+export const patchStartOAuth = async ({ dispatcher, decrypted }) => {
+    dispatcher.startOAuth = async function () {
+        if (!dispatcher._oauth)
+            throw new Error("oauth not configured");
+        const authorizationURL = process.env.OAUTH_AUTHORIZATION_URL ||
+            decrypted.authorizationURL ||
+            dispatcher._oauth.authorizationURL;
+        if (!authorizationURL)
+            throw new Error("authorizationURL not configured");
+        const clientId = decrypted.clientId ||
+            process.env.OAUTH_CLIENT_ID ||
+            dispatcher._oauth.clientId;
+        if (!clientId)
+            throw new Error("clientId not configured");
+        const scopes = process.env.OAUTH_SCOPE ||
+            decrypted.scope ||
+            dispatcher._oauth.scope ||
+            "";
+        const useCodeChallenge = !!dispatcher._oauth.useCodeChallenge;
+        return {
+            url: authorizationURL
+                .replace(/\{\{clientId\}\}/gi, encodeURIComponent(clientId))
+                .replace(/\{\{scope\}\}/gi, encodeURIComponent(scopes)),
+            useCodeChallenge,
+        };
+    };
+};

package/build/internal/connector/server/on-connect.d.mts

@@ -0,0 +1,8 @@
+import Dispatcher from "../../dispatcher/index.mjs";
+import { Config } from "../../websocket/config.mjs";
+export declare const onConnect: ({ dispatcher, configSchema, config, start }: {
+    config: Config;
+    configSchema: any;
+    start: any;
+    dispatcher: Dispatcher;
+}) => (transport: any) => void;