@superblocksteam/sdk 1.4.2 → 1.5.0

package/dist/socket/signing.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.verifyResources = exports.signResource = void 0;
+const tslib_1 = require("tslib");
+const axios_1 = tslib_1.__importDefault(require("axios"));
+const utils_1 = require("../utils");
+async function signResource({ token, branchName, resource, agentUrls, }) {
+    const requestResource = {
+        branchName: branchName !== null && branchName !== void 0 ? branchName : "main",
+    };
+    if (resource.api) {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+        requestResource.api = (0, utils_1.getSanitizedApi)(resource.api);
+    }
+    else {
+        requestResource.literal = resource.literal;
+    }
+    try {
+        const resp = await callAgentFallBack({
+            baseUrls: agentUrls,
+            path: "v1/signature/sign",
+            method: "post",
+            token: token,
+            data: { resource: requestResource },
+        });
+        return resp.signature;
+    }
+    catch (e) {
+        throw new Error("No agents available to sign the resource");
+    }
+}
+exports.signResource = signResource;
+async function verifyResources({ agentUrls, token, branchName, resources, }) {
+    try {
+        await callAgentFallBack({
+            baseUrls: agentUrls,
+            path: "v1/signature/verify",
+            method: "post",
+            token: token,
+            data: {
+                resources: resources.map((res) => {
+                    if (res.api) {
+                        return {
+                            // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+                            api: (0, utils_1.getSanitizedApi)(res.api),
+                            branchName: branchName !== null && branchName !== void 0 ? branchName : "main",
+                        };
+                    }
+                    return {
+                        ...res,
+                        branchName: branchName !== null && branchName !== void 0 ? branchName : "main",
+                    };
+                }),
+            },
+        });
+    }
+    catch (e) {
+        throw new Error("No agents available to verify the resource");
+    }
+}
+exports.verifyResources = verifyResources;
+async function callAgentFallBack({ baseUrls, path, method, token, data, }) {
+    for (const baseUrl of baseUrls) {
+        try {
+            const url = new URL(path, baseUrl);
+            const config = {
+                url: url.toString(),
+                method: method,
+                headers: {
+                    Authorization: "Bearer " + token,
+                },
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+                data: data,
+            };
+            const resp = await (0, axios_1.default)(config);
+            return resp.data;
+        }
+        catch (e) { }
+    }
+    throw new Error("Failed to request ");
+}

package/dist/socket/socket.d.ts

@@ -0,0 +1,16 @@
+/// <reference types="ws" />
+import WebSocket from "isomorphic-ws";
+import { ISocketClient, MethodHandlers } from "../types";
+export declare class ISocket<ImplementedMethods, CallableMethods, RequestContext> {
+    private readonly ws;
+    private readonly requestHandlers;
+    private readonly responseHandler;
+    private peerAuthorization?;
+    private nxtRequestId;
+    constructor(ws: WebSocket, requestHandlers: MethodHandlers<ImplementedMethods, CallableMethods, RequestContext>);
+    request<Params, Result>(method: string, params: Params, authorization?: string): Promise<Result>;
+    private respond;
+    private respondError;
+    close(): void;
+}
+export declare function createISocketClient<CallableMethods, ImplementedMethods, RequestContext>(socket: ISocket<ImplementedMethods, CallableMethods, RequestContext>): ISocketClient<CallableMethods>;

package/dist/socket/socket.js

@@ -0,0 +1,157 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createISocketClient = exports.ISocket = void 0;
+class ISocket {
+    constructor(ws, requestHandlers) {
+        this.responseHandler = {};
+        this.ws = ws;
+        this.requestHandlers = requestHandlers;
+        this.nxtRequestId = 0;
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-ignore
+        this.ws.addEventListener("message", async (event) => {
+            const eventData = JSON.parse(event.data.toString());
+            if (eventData.request) {
+                // Split the method string into parts
+                const parts = eventData.request.method.split(".");
+                let handlers = this.requestHandlers;
+                for (const part of parts) {
+                    // @ts-ignore
+                    handlers = handlers[part];
+                    if (!handlers) {
+                        return await this.respondError(eventData.request.id, {
+                            code: 2,
+                            message: `unknown method ${eventData.request.method}`,
+                        });
+                    }
+                }
+                if (!Array.isArray(handlers)) {
+                    return await this.respondError(eventData.request.id, {
+                        code: 2,
+                        message: "unknown method",
+                    });
+                }
+                if (eventData.request.setAuthorization) {
+                    this.peerAuthorization = eventData.request.setAuthorization;
+                }
+                const middlewareHandlers = handlers.slice(0, -1);
+                const handler = handlers[handlers.length - 1];
+                const reqCtx = {};
+                let response;
+                // TODO(george): maybe we should not create a new client for each request
+                const client = createISocketClient(this);
+                try {
+                    for (const middlewareHandler of middlewareHandlers) {
+                        await middlewareHandler(eventData.request.payload, this.peerAuthorization, client, reqCtx);
+                    }
+                    response = await handler(eventData.request.payload, client, reqCtx);
+                }
+                catch (error) {
+                    return await this.respondError(eventData.request.id, {
+                        code: 3,
+                        message: error.toString(),
+                    });
+                }
+                await this.respond(eventData.request.id, response);
+            }
+            else if (eventData.response && eventData.response.id) {
+                if (!this.responseHandler[eventData.response.id]) {
+                    return;
+                }
+                if (eventData.response.error) {
+                    this.responseHandler[eventData.response.id].reject(eventData.response.error);
+                }
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                this.responseHandler[eventData.response.id].resolve(eventData.response.payload);
+                delete this.responseHandler[eventData.response.id];
+            }
+            else {
+                return await this.respondError(-1, {
+                    code: 3,
+                    message: "unknown request id",
+                });
+            }
+        });
+    }
+    request(method, params, authorization) {
+        return new Promise((resolve, reject) => {
+            const requestId = ++this.nxtRequestId;
+            this.responseHandler[requestId] = {
+                resolve: (result) => resolve(result),
+                reject: (error) => reject(error),
+            };
+            const toSend = {
+                request: {
+                    method,
+                    payload: params,
+                    id: requestId,
+                    setAuthorization: authorization,
+                },
+            };
+            this.ws.send(JSON.stringify(toSend));
+        });
+    }
+    async respond(requestId, result) {
+        const toSend = {
+            response: {
+                payload: result,
+                id: requestId,
+                error: null,
+            },
+        };
+        return this.ws.send(JSON.stringify(toSend));
+    }
+    async respondError(requestId, error) {
+        const toSend = {
+            response: {
+                payload: null,
+                id: requestId,
+                error: error,
+            },
+        };
+        return this.ws.send(JSON.stringify(toSend));
+    }
+    close() {
+        this.ws.close();
+    }
+}
+exports.ISocket = ISocket;
+const proxyTarget = Object.freeze(() => {
+    /* return nothing */
+});
+function createIsocketProxy(socket, 
+// if path is undefined, it means the current object is the root object
+path) {
+    return new Proxy(proxyTarget, {
+        get(_target, prop) {
+            const childPath = path ? `${path}.${prop}` : prop;
+            // sometimes, when `createISocketClient` is called from an async function, JS will implicitly call the `then` method on
+            // its return value, because promises can be arbitrarily nested
+            // so return undefined for the `then` method to avoid this
+            if (childPath === "then") {
+                return undefined;
+            }
+            return createIsocketProxy(socket, childPath);
+        },
+        apply(_target, _thisArg, args) {
+            if (path === undefined) {
+                throw new Error("The root object is not callable");
+            }
+            if (path.endsWith(".apply") &&
+                args.length === 2 &&
+                Array.isArray(args[1])) {
+                path = path.slice(0, -".apply".length);
+                args = args[1];
+            }
+            return socket.request(path, args[0]);
+        },
+    });
+}
+function createISocketClient(socket) {
+    return {
+        close: () => socket.close(),
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any,@typescript-eslint/no-unsafe-assignment
+        call: createIsocketProxy(socket, undefined),
+    };
+}
+exports.createISocketClient = createISocketClient;

package/dist/types/common.d.ts

@@ -0,0 +1,111 @@
+export interface UserMeDto {
+    user: User;
+    organizations: Organization[];
+    agents: Agent[];
+    flagBootstrap: FlagBootstrap;
+}
+export interface FlagBootstrap {
+    "ui.enable-resource-signing"?: boolean;
+}
+export type User = {
+    id: string;
+    email: string;
+    currentOrganizationId: string;
+    organizationIds: string[];
+    username: string;
+    name: string;
+    anonymousId: string;
+    isAnonymous: boolean;
+    isAdmin: boolean;
+    metadata: Record<string, unknown>;
+};
+export interface Organization {
+    id: string;
+    name: string;
+    displayName: string;
+    agents?: Agent[];
+    apiKey: string;
+    agentType: AgentType;
+    minExternalAgentVersion: string;
+    profiles?: Profile[];
+}
+export type Agent = {
+    id: string;
+    key: string;
+    environment: string;
+    status: AgentStatus;
+    version: string;
+    versionExternal: string;
+    url: string;
+    type: AgentType;
+    updated: Date;
+    created: Date;
+    tags: AgentTags;
+    verificationKeyIds?: null | string[];
+    signingKeyId?: null | string;
+};
+export declare enum AgentStatus {
+    ACTIVE = "Active",
+    DISCONNECTED = "Disconnected",
+    BROWSER_UNREACHABLE = "Browser Unreachable",
+    PENDING_REGISTRATION = "Pending Registration",
+    STALE = "Stale"
+}
+export declare enum AgentType {
+    MULTITENANT = 0,
+    DEDICATED = 1,
+    ONPREMISE = 2
+}
+export type AgentTags = Record<string, string[]>;
+export declare class Profile {
+    id: string;
+    key: string;
+    displayName: string;
+    description: string;
+    type: ProfileType;
+    constructor({ id, key, displayName, description, type, }: {
+        id: string;
+        key: string;
+        displayName: string;
+        description: string;
+        type: ProfileType;
+    });
+}
+export declare enum ProfileType {
+    RESERVED = "RESERVED",
+    CUSTOM = "CUSTOM"
+}
+export type Api = {
+    metadata: {
+        name: string;
+        id: string;
+        organization: string;
+        timestamps?: {
+            created: string;
+            updated: string;
+            deactivated: boolean;
+        };
+        creator?: {
+            id: string;
+            name: string;
+        };
+        folder?: string;
+    };
+    blocks?: any[];
+    trigger: any;
+    signature?: Signature;
+};
+/** A signature, as produced by the agent. */
+export interface Signature {
+    /** The id of the key used to sign the data. */
+    keyId: string;
+    /** The actual signature, in base64. */
+    data: string;
+}
+export interface RemoteCommitDto {
+    commitId: string;
+    remoteCommitId: string;
+    remoteCommitDate: Date;
+    branchName: string;
+    repositoryId: string;
+}

package/dist/types/common.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProfileType = exports.Profile = exports.AgentType = exports.AgentStatus = void 0;
+var AgentStatus;
+(function (AgentStatus) {
+    AgentStatus["ACTIVE"] = "Active";
+    AgentStatus["DISCONNECTED"] = "Disconnected";
+    AgentStatus["BROWSER_UNREACHABLE"] = "Browser Unreachable";
+    // TODO: remove PENDING_REGISTRATION after the DB migration
+    AgentStatus["PENDING_REGISTRATION"] = "Pending Registration";
+    AgentStatus["STALE"] = "Stale";
+})(AgentStatus || (exports.AgentStatus = AgentStatus = {}));
+var AgentType;
+(function (AgentType) {
+    AgentType[AgentType["MULTITENANT"] = 0] = "MULTITENANT";
+    AgentType[AgentType["DEDICATED"] = 1] = "DEDICATED";
+    AgentType[AgentType["ONPREMISE"] = 2] = "ONPREMISE";
+})(AgentType || (exports.AgentType = AgentType = {}));
+class Profile {
+    constructor({ id, key, displayName, description, type, }) {
+        this.id = id;
+        this.key = key;
+        this.displayName = displayName;
+        this.description = description;
+        this.type = type;
+    }
+}
+exports.Profile = Profile;
+var ProfileType;
+(function (ProfileType) {
+    ProfileType["RESERVED"] = "RESERVED";
+    ProfileType["CUSTOM"] = "CUSTOM";
+})(ProfileType || (exports.ProfileType = ProfileType = {}));

package/dist/types/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./common";
+export * from "./socket";
+export * from "./plugin";
+export * from "./signing";

package/dist/types/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./common"), exports);
+tslib_1.__exportStar(require("./socket"), exports);
+tslib_1.__exportStar(require("./plugin"), exports);
+tslib_1.__exportStar(require("./signing"), exports);

package/dist/types/plugin.d.ts

@@ -0,0 +1,2 @@
+export declare const transcribeAudioToTextTranslateToEnglishTruthyValues: (string | boolean)[];
+export declare const OpenAiPluginId = "openai";

package/dist/types/plugin.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpenAiPluginId = exports.transcribeAudioToTextTranslateToEnglishTruthyValues = void 0;
+exports.transcribeAudioToTextTranslateToEnglishTruthyValues = [
+    "checked",
+    "true",
+    true,
+];
+exports.OpenAiPluginId = "openai";

package/dist/types/signing.d.ts

@@ -0,0 +1,51 @@
+import { Api as ApiPb, Signature } from "./common";
+export type SignatureResponse = {
+    signature: Signature;
+};
+export type ApiResource = {
+    api: ApiPb;
+};
+export type GenericResource = {
+    literal: {
+        data: any;
+        signature?: Signature;
+    };
+};
+interface PageHash {
+    /** The version of the page DSL. */
+    version: number;
+    /** The SHA-256 hash of the page DSL (i.e. `page.layouts[0].dsl`), in base64. */
+    hash: string;
+}
+export interface ApplicationSettingsHashes {
+    /** The SHA-256 hash of all custom components related properties from settings, in base64. */
+    components: string;
+    /** The SHA-256 hash of settings without the custom components related properties, in base64. */
+    rest: string;
+}
+export interface ApplicationSignatureTree {
+    /** The version of the signature tree. */
+    v: 1;
+    settings: ApplicationSettingsHashes;
+    page: PageHash;
+}
+export interface ApplicationSignatureTreeSigned {
+    /** The SHA-256 hash of `root`, in base64. */
+    signature: Signature;
+    root: ApplicationSignatureTree;
+}
+export type AppToSign = {
+    rootHash: string;
+};
+export type AppToVerify = {
+    rootHash: string;
+    signature?: Signature;
+};
+export type ApiToSign = {
+    apiPb: ApiPb;
+};
+export type ApiToVerify = {
+    apiPb: ApiPb;
+    signature?: Signature;
+};
+export {};

package/dist/types/signing.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/socket.d.ts

@@ -0,0 +1,17 @@
+export type MethodHandler<Params, Result, PeerMethods, RequestContext> = (params: Params, peer: ISocketClient<PeerMethods>, ctx: RequestContext) => Promise<Result>;
+export type MiddlewareHandler<Params, PeerMethods, RequestContext> = (params: Params, peerAuthorization: string | undefined, peer: ISocketClient<PeerMethods>, ctx: RequestContext) => Promise<void>;
+export type MethodHandlers<Methods, PeerMethods, RequestContext> = {
+    [Key in keyof Methods]: Methods[Key] extends (params: infer Params) => Promise<infer Result> ? [
+        ...middlewareHandlers: MiddlewareHandler<Params, PeerMethods, RequestContext>[],
+        handler: MethodHandler<Params, Result, PeerMethods, RequestContext>
+    ] : Methods[Key] extends Record<string, unknown> ? MethodHandlers<Methods[Key], PeerMethods, RequestContext> : never;
+};
+type ISocketClientMethodCall<Methods> = {
+    [Key in keyof Methods]: Methods[Key] extends (params: infer P) => Promise<infer R> ? (params: P) => Promise<R> : Methods[Key] extends Record<string, unknown> ? ISocketClientMethodCall<Methods[Key]> : never;
+};
+export type ISocketClient<Methods> = {
+    close: () => void;
+    call: ISocketClientMethodCall<Methods>;
+};
+export type MethodSchema<Params, Response> = (params: Params) => Promise<Response>;
+export {};

package/dist/types/socket.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/utils.d.ts

@@ -0,0 +1,4 @@
+import { Agent, AgentType, Api } from "./types";
+export declare function getAgentUrls(agents: Agent[], agentType: AgentType): string[];
+export declare const sanitizeV2RequestBody: (apiBody: Record<string, unknown>) => Record<string, unknown>;
+export declare const getSanitizedApi: (api: Api) => any;

package/dist/utils.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSanitizedApi = exports.sanitizeV2RequestBody = exports.getAgentUrls = void 0;
+const types_1 = require("./types");
+function getAgentUrls(agents, agentType) {
+    const filtered = agents.filter((a) => a.type === agentType && a.status === types_1.AgentStatus.ACTIVE);
+    return filtered.map((f) => f.url);
+}
+exports.getAgentUrls = getAgentUrls;
+const sanitizeV2RequestBody = (apiBody) => {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const traverseJSON = (obj) => {
+        for (const key in obj) {
+            if (key === "step" && obj.step[types_1.OpenAiPluginId]) {
+                const value = obj.step[types_1.OpenAiPluginId].transcribeAudioToTextTranslateToEnglish;
+                obj.step[types_1.OpenAiPluginId].transcribeAudioToTextTranslateToEnglish =
+                    types_1.transcribeAudioToTextTranslateToEnglishTruthyValues.includes(value);
+            }
+            else if (typeof obj[key] === "object") {
+                (0, exports.sanitizeV2RequestBody)(obj[key]);
+            }
+        }
+    };
+    traverseJSON(apiBody);
+    return apiBody;
+};
+exports.sanitizeV2RequestBody = sanitizeV2RequestBody;
+const getSanitizedApi = (api) => {
+    var _a, _b;
+    const sanitizedBlocks = (_b = ((_a = api.blocks) !== null && _a !== void 0 ? _a : [])) === null || _b === void 0 ? void 0 : _b.map((block) => (0, exports.sanitizeV2RequestBody)(block));
+    return {
+        ...api,
+        blocks: sanitizedBlocks,
+    };
+};
+exports.getSanitizedApi = getSanitizedApi;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@superblocksteam/sdk",
-  "version": "1.4.2",
+  "version": "1.5.0",
   "description": "Superblocks JS SDK",
   "main": "./dist/index.js",
   "exports": {
@@ -22,6 +22,7 @@
   },
   "license": "Superblocks Community Software License",
   "devDependencies": {
+    "@types/ws": "^8.5.10",
     "@typescript-eslint/eslint-plugin": "^5.60.1",
     "@typescript-eslint/parser": "^5.60.1",
     "eslint": "^8.48.0",
@@ -30,8 +31,9 @@
     "typescript": "^5.1.3"
   },
   "dependencies": {
-    "@superblocksteam/util": "1.4.2",
-    "axios": "^1.3.5"
+    "@superblocksteam/util": "1.5.0",
+    "axios": "^1.3.5",
+    "isomorphic-ws": "^5.0.0"
   },
   "homepage": "https://www.superblocks.com",
   "engines": {