@superblocksteam/sdk 1.4.2 → 1.5.1

package/src/socket/socket.ts

@@ -0,0 +1,253 @@
+import WebSocket from "isomorphic-ws";
+import {
+  ISocketClient,
+  MethodHandler,
+  MethodHandlers,
+  MiddlewareHandler,
+} from "../types";
+
+interface SocketRequest<Payload = unknown> {
+  method: string;
+  payload: Payload;
+  id: number;
+  setAuthorization?: string;
+}
+
+interface SocketResponse<Payload = unknown> {
+  id: number;
+  payload: Payload;
+  error: SocketError | null;
+}
+
+interface SocketMessage<RequestPayload = unknown, ResponsePayload = unknown> {
+  request?: SocketRequest<RequestPayload>;
+  response?: SocketResponse<ResponsePayload>;
+}
+
+interface SocketError {
+  message: string;
+  code: number;
+}
+
+export class ISocket<ImplementedMethods, CallableMethods, RequestContext> {
+  private readonly ws: WebSocket;
+  private readonly requestHandlers: MethodHandlers<
+    ImplementedMethods,
+    CallableMethods,
+    RequestContext
+  >;
+  private readonly responseHandler: {
+    [requestId: number]: {
+      resolve: (data: unknown) => void;
+      reject: (error: SocketError) => void;
+    };
+  } = {};
+  private peerAuthorization?: string;
+  private nxtRequestId: number;
+
+  constructor(
+    ws: WebSocket,
+    requestHandlers: MethodHandlers<
+      ImplementedMethods,
+      CallableMethods,
+      RequestContext
+    >
+  ) {
+    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: MessageEvent) => {
+      const eventData: SocketMessage = 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) as MiddlewareHandler<
+          unknown,
+          CallableMethods,
+          RequestContext
+        >[];
+        const handler = handlers[handlers.length - 1] as MethodHandler<
+          unknown,
+          unknown,
+          CallableMethods,
+          RequestContext
+        >;
+        const reqCtx = {} as RequestContext;
+        let response: unknown;
+        // 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: any) {
+          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 as any
+        );
+        delete this.responseHandler[eventData.response.id];
+      } else {
+        return await this.respondError(-1, {
+          code: 3,
+          message: "unknown request id",
+        });
+      }
+    });
+  }
+
+  public request<Params, Result>(
+    method: string,
+    params: Params,
+    authorization?: string
+  ): Promise<Result> {
+    return new Promise<Result>((resolve, reject) => {
+      const requestId = ++this.nxtRequestId;
+      this.responseHandler[requestId] = {
+        resolve: (result) => resolve(result as Result),
+        reject: (error: SocketError) => reject(error),
+      };
+      const toSend: SocketMessage = {
+        request: {
+          method,
+          payload: params,
+          id: requestId,
+          setAuthorization: authorization,
+        },
+      };
+      this.ws.send(JSON.stringify(toSend));
+    });
+  }
+
+  private async respond<Result>(
+    requestId: number,
+    result: Result
+  ): Promise<void> {
+    const toSend: SocketMessage = {
+      response: {
+        payload: result,
+        id: requestId,
+        error: null,
+      },
+    };
+    return this.ws.send(JSON.stringify(toSend));
+  }
+
+  private async respondError(
+    requestId: number,
+    error: SocketError
+  ): Promise<void> {
+    const toSend: SocketMessage = {
+      response: {
+        payload: null,
+        id: requestId,
+        error: error,
+      },
+    };
+    return this.ws.send(JSON.stringify(toSend));
+  }
+
+  public close(): void {
+    this.ws.close();
+  }
+}
+
+const proxyTarget = Object.freeze(() => {
+  /* return nothing */
+});
+
+function createIsocketProxy<
+  ImplementedMethods,
+  CallableMethods,
+  RequestContext
+>(
+  socket: ISocket<ImplementedMethods, CallableMethods, RequestContext>,
+  // if path is undefined, it means the current object is the root object
+  path: string | undefined
+): unknown {
+  return new Proxy(proxyTarget, {
+    get(_target, prop: string) {
+      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: unknown[]) {
+      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]);
+    },
+  });
+}
+
+export function createISocketClient<
+  CallableMethods,
+  ImplementedMethods,
+  RequestContext
+>(
+  socket: ISocket<ImplementedMethods, CallableMethods, RequestContext>
+): ISocketClient<CallableMethods> {
+  return {
+    close: () => socket.close(),
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any,@typescript-eslint/no-unsafe-assignment
+    call: createIsocketProxy(socket, undefined) as any,
+  };
+}

package/src/types/common.ts

@@ -0,0 +1,138 @@
+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 enum AgentStatus {
+  ACTIVE = "Active",
+  DISCONNECTED = "Disconnected",
+  BROWSER_UNREACHABLE = "Browser Unreachable",
+  // TODO: remove PENDING_REGISTRATION after the DB migration
+  PENDING_REGISTRATION = "Pending Registration",
+  STALE = "Stale",
+}
+
+export enum AgentType {
+  MULTITENANT = 0,
+  DEDICATED = 1,
+  ONPREMISE = 2,
+}
+
+export type AgentTags = Record<string, string[]>;
+
+export 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;
+  }) {
+    this.id = id;
+    this.key = key;
+    this.displayName = displayName;
+    this.description = description;
+    this.type = type;
+  }
+}
+
+export enum ProfileType {
+  RESERVED = "RESERVED",
+  CUSTOM = "CUSTOM",
+}
+
+export type Api = {
+  metadata: {
+    name: string;
+    id: string;
+    organization: string;
+    timestamps?: {
+      created: string;
+      updated: string;
+      deactivated: boolean;
+    };
+    // These properties are merged in from the v3 api entity
+    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/src/types/index.ts

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

package/src/types/plugin.ts

@@ -0,0 +1,7 @@
+export const transcribeAudioToTextTranslateToEnglishTruthyValues = [
+  "checked",
+  "true",
+  true,
+];
+
+export const OpenAiPluginId = "openai";

package/src/types/signing.ts

@@ -0,0 +1,61 @@
+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;
+};

package/src/types/socket.ts

@@ -0,0 +1,48 @@
+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>;

package/src/utils.ts

@@ -0,0 +1,81 @@
+import axios, { AxiosRequestConfig } from "axios";
+import {
+  Agent,
+  AgentStatus,
+  AgentType,
+  Api,
+  OpenAiPluginId,
+  transcribeAudioToTextTranslateToEnglishTruthyValues,
+} from "./types";
+
+export async function getAgentUrl(
+  agents: Agent[],
+  agentType: AgentType,
+  profile?: string,
+  healthCheck = true
+): Promise<string> {
+  let filtered = agents.filter(
+    (a) => a.type === agentType && a.status === AgentStatus.ACTIVE
+  );
+  if (profile) {
+    filtered = agents.filter(
+      (a) =>
+        a.tags.profile &&
+        (a.tags.profile.includes("*") || a.tags.profile.includes(profile))
+    );
+  }
+  if (healthCheck) {
+    const coroutines: Promise<string>[] = [];
+    for (const agent of filtered) {
+      const p: Promise<string> = (async () => {
+        const url = new URL("health", agent.url);
+        const config: AxiosRequestConfig = {
+          url: url.toString(),
+          method: "get",
+          headers: {},
+        };
+        await axios(config);
+        return agent.url;
+      })();
+      coroutines.push(p);
+    }
+    try {
+      return await Promise.any(coroutines);
+    } catch (e) {
+      throw new Error("No available agents");
+    }
+  } else {
+    const randomIndex = Math.floor(Math.random() * filtered.length);
+    return filtered[randomIndex].url;
+  }
+}
+
+export const sanitizeV2RequestBody = (
+  apiBody: Record<string, unknown>
+): Record<string, unknown> => {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  const traverseJSON = (obj: any) => {
+    for (const key in obj) {
+      if (key === "step" && obj.step[OpenAiPluginId]) {
+        const value =
+          obj.step[OpenAiPluginId].transcribeAudioToTextTranslateToEnglish;
+        obj.step[OpenAiPluginId].transcribeAudioToTextTranslateToEnglish =
+          transcribeAudioToTextTranslateToEnglishTruthyValues.includes(value);
+      } else if (typeof obj[key] === "object") {
+        sanitizeV2RequestBody(obj[key]);
+      }
+    }
+  };
+  traverseJSON(apiBody);
+  return apiBody;
+};
+
+export const getSanitizedApi = (api: Api): any => {
+  const sanitizedBlocks = (api.blocks ?? [])?.map(
+    (block: Record<string, unknown>) => sanitizeV2RequestBody(block)
+  );
+  return {
+    ...api,
+    blocks: sanitizedBlocks,
+  };
+};

package/tsconfig.json

@@ -6,7 +6,9 @@
     "outDir": "dist",
     "rootDir": "src",
     "strict": true,
-    "target": "es2019"
+    "target": "es2021",
+    "esModuleInterop": true,
+    "skipLibCheck": true
   },
   "include": ["src/**/*"]
 }