@superblocksteam/sdk 1.4.2 → 1.5.0

package/.eslintrc.json

@@ -27,6 +27,9 @@
     "@typescript-eslint/no-unsafe-return": "off",
     "@typescript-eslint/no-unsafe-member-access": "off",
     "@typescript-eslint/restrict-template-expressions": "off",
+    "@typescript-eslint/no-unsafe-assignment": "off",
+    "@typescript-eslint/no-unsafe-argument": "off",
+    "@typescript-eslint/no-unsafe-call": "off",
     "import/order": [
       "error",
       {

package/dist/client.d.ts

@@ -1,4 +1,5 @@
 import { ComponentEvent, LocalGitRepoState, SuperblocksResourceType } from "@superblocksteam/util";
+import { RemoteCommitDto, UserMeDto } from "./types";
 export type ViewMode = "export-deployed" | "export-latest" | "export-live";
 export interface UploadFile {
     name: string;
@@ -63,7 +64,7 @@ export declare function fetchApis(cliVersion: string, token: string, superblocks
 export declare function validateGitSetup(cliVersion: string, resourceId: string, resourceType: SuperblocksResourceType, event: ComponentEvent, localGitRepoState: LocalGitRepoState, token: string, superblocksBaseUrl: string, injectedHeaders?: Record<string, string>): Promise<{
     branchName: string | null;
 }>;
-export declare function registerComponents(cliVersion: string, applicationId: string, componentConfigs: Record<string, any>, token: string, superblocksBaseUrl: string, branch: string | null, injectedHeaders?: Record<string, string>): Promise<any>;
+export declare function registerComponents(cliVersion: string, applicationId: string, componentConfigs: Record<string, any>, token: string, superblocksBaseUrl: string, branch: string | null, injectedHeaders: Record<string, string>): Promise<any>;
 export declare function uploadComponents({ cliVersion, applicationId, componentConfigs, files, token, superblocksBaseUrl, branch, }: {
     cliVersion: string;
     applicationId: string;
@@ -72,8 +73,8 @@ export declare function uploadComponents({ cliVersion, applicationId, componentC
     token: string;
     superblocksBaseUrl: string;
     branch: string | null;
-}): Promise<any>;
-export declare function fetchCurrentUser(cliVersion: string, token: string, superblocksBaseUrl: string): Promise<any>;
+}): Promise<void>;
+export declare function fetchCurrentUser(cliVersion: string, token: string, superblocksBaseUrl: string): Promise<UserMeDto>;
 export declare function pushApplication({ cliVersion, applicationId, token, superblocksBaseUrl, applicationConfig, branch, injectedHeaders, }: {
     cliVersion: string;
     applicationId: string;
@@ -82,7 +83,7 @@ export declare function pushApplication({ cliVersion, applicationId, token, supe
     branch: string;
     injectedHeaders: Record<string, string>;
     applicationConfig: PushApplicationWithCommitConfig;
-}): Promise<ApplicationWrapper | undefined>;
+}): Promise<RemoteCommitDto | undefined>;
 export declare function pushApi({ cliVersion, apiId, token, superblocksBaseUrl, apiConfig, branch, injectedHeaders, }: {
     cliVersion: string;
     apiId: string;

package/dist/client.js

@@ -1,13 +1,18 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.pushApi = exports.pushApplication = exports.fetchCurrentUser = exports.uploadComponents = exports.registerComponents = exports.validateGitSetup = exports.fetchApis = exports.fetchApi = exports.fetchApplications = exports.fetchApplicationWithComponents = exports.fetchApplicationBranches = exports.fetchApplication = void 0;
-const fs = require("fs");
+const tslib_1 = require("tslib");
+const fs = tslib_1.__importStar(require("fs"));
 const util_1 = require("@superblocksteam/util");
-const axios_1 = require("axios");
-const FormData = require("form-data");
+const axios_1 = tslib_1.__importStar(require("axios"));
+const form_data_1 = tslib_1.__importDefault(require("form-data"));
 const lodash_1 = require("lodash");
 const errors_1 = require("./errors");
-const BASE_BUCKETEER_URL = "api/v1";
+const flag_1 = require("./flag");
+const socket_1 = require("./socket");
+const types_1 = require("./types");
+const utils_1 = require("./utils");
+const BASE_BUCKETEER_URL = "api";
 const BASE_SERVER_PUBLIC_API_URL = "api/v1/public";
 const SUPERBLOCKS_MAX_FILE_SIZE_MB = 10;
 const CLI_VERSION_HEADER = "x-superblocks-cli-version";
@@ -91,7 +96,7 @@ async function fetchApplicationWithComponents({ cliVersion, applicationId, branc
     const bucketeerBaseUrl = (0, util_1.getBucketeerUrlFromSuperblocksUrl)(superblocksBaseUrl);
     // fetch files from bucketeer
     const branchPath = branch ? `/branches/${encodeURIComponent(branch)}` : "";
-    const componentFileURL = new URL(`${BASE_BUCKETEER_URL}/components/${applicationId}${branchPath}?commit=${commitId}&viewMode=${viewMode}`, bucketeerBaseUrl).toString();
+    const componentFileURL = new URL(`${BASE_BUCKETEER_URL}/v1/components/${applicationId}${branchPath}?commit=${commitId}&viewMode=${viewMode}`, bucketeerBaseUrl).toString();
     try {
         const config = {
             method: "get",
@@ -244,18 +249,39 @@ async function registerComponents(cliVersion, applicationId, componentConfigs, t
     var _a, _b, _c, _d, _e, _f, _g;
     try {
         const branchPath = branch ? `/branches/${encodeURIComponent(branch)}` : "";
-        const config = {
-            method: "put",
-            url: new URL(`${BASE_SERVER_PUBLIC_API_URL}/application/${applicationId}${branchPath}/components`, superblocksBaseUrl).toString(),
-            headers: {
-                Authorization: "Bearer " + token,
-                [CLI_VERSION_HEADER]: cliVersion,
-                ...injectedHeaders,
-            },
-            data: { components: componentConfigs },
-        };
-        const response = await (0, axios_1.default)(config);
-        return response.data;
+        const userMe = await fetchCurrentUser(cliVersion, token, superblocksBaseUrl);
+        const organization = userMe.organizations[0];
+        if (organization.agentType == types_1.AgentType.ONPREMISE && (0, flag_1.signingEnabled)(userMe.flagBootstrap)) {
+            const agentUrls = (0, utils_1.getAgentUrls)(userMe.agents, organization.agentType);
+            const socket = await (0, socket_1.connectToISocketRPCServer)({
+                agentUrls,
+                superblocksBaseUrl,
+                token,
+            });
+            const resp = await socket.call.v1.public.application.component.register({
+                applicationId,
+                branchName: branch || "",
+                cliVersion: cliVersion,
+                componentEvent: injectedHeaders[util_1.COMPONENT_EVENT_HEADER],
+                components: componentConfigs,
+            });
+            socket.close();
+            return resp.data;
+        }
+        else {
+            const config = {
+                method: "put",
+                url: new URL(`${BASE_SERVER_PUBLIC_API_URL}/application/${applicationId}${branchPath}/components`, superblocksBaseUrl).toString(),
+                headers: {
+                    Authorization: "Bearer " + token,
+                    [CLI_VERSION_HEADER]: cliVersion,
+                    ...injectedHeaders,
+                },
+                data: { components: componentConfigs },
+            };
+            const response = await (0, axios_1.default)(config);
+            return response.data;
+        }
     }
     catch (e) {
         if (e instanceof axios_1.AxiosError) {
@@ -292,9 +318,9 @@ async function uploadComponents({ cliVersion, applicationId, componentConfigs, f
         srcFiles,
         buildFiles,
     });
-    const postURL = new URL(`${BASE_BUCKETEER_URL}/components/upload`, bucketeerBaseUrl).toString();
+    const postURL = new URL(`${BASE_BUCKETEER_URL}/v2/components/upload`, bucketeerBaseUrl).toString();
     let totalFileSizeMB = 0;
-    const formData = new FormData();
+    const formData = new form_data_1.default();
     formData.append("format", formatJSON);
     uploadFiles.forEach((uploadFile) => {
         const uploadFileStats = fs.statSync(uploadFile.filename);
@@ -320,8 +346,34 @@ You can reduce your component bundle size by uploading static assets to a separa
                 ...formHeaders,
             },
         };
-        const response = await axios_1.default.post(postURL, formData, config);
-        return response.data;
+        const uploadResponse = await axios_1.default.post(postURL, formData, config);
+        const userMe = await fetchCurrentUser(cliVersion, token, superblocksBaseUrl);
+        const organization = userMe.organizations[0];
+        const signingRequired = organization.agentType == types_1.AgentType.ONPREMISE && (0, flag_1.signingEnabled)(userMe.flagBootstrap);
+        let agentUrls = [];
+        if (signingRequired) {
+            agentUrls = (0, utils_1.getAgentUrls)(userMe.agents, organization.agentType);
+        }
+        const socket = await (0, socket_1.connectToISocketRPCServer)({
+            agentUrls,
+            superblocksBaseUrl,
+            token,
+        });
+        try {
+            await socket.call.v1.public.application.component.update({
+                applicationId,
+                branchName: branch !== null && branch !== void 0 ? branch : undefined,
+                srcFiles: srcFiles.map((file) => file.filename),
+                buildFiles: buildFiles.map((file) => file.filename),
+                registeredComponents: componentConfigs,
+                cliVersion,
+                componentBaseUrl: uploadResponse.data.componentBaseUrl,
+                signingRequired,
+            });
+        }
+        finally {
+            socket.close();
+        }
     }
     catch (e) {
         if (e instanceof axios_1.AxiosError && ((_a = e.response) === null || _a === void 0 ? void 0 : _a.status) === 413) {
@@ -358,7 +410,7 @@ async function fetchCurrentUser(cliVersion, token, superblocksBaseUrl) {
             },
         };
         const response = await (0, axios_1.default)(config);
-        return response.data.data.user;
+        return response.data.data;
     }
     catch (e) {
         let message;
@@ -378,17 +430,40 @@ async function pushApplication({ cliVersion, applicationId, token, superblocksBa
     const serverURL = new URL(`${BASE_SERVER_PUBLIC_API_URL}/applications/${applicationId}/branches/${encodeURIComponent(branch)}/push`, superblocksBaseUrl);
     let serverResponse;
     try {
-        const config = {
-            method: "post",
-            url: serverURL.toString(),
-            headers: {
-                Authorization: "Bearer " + token,
-                [CLI_VERSION_HEADER]: cliVersion,
-                ...injectedHeaders,
-            },
-            data: applicationConfig,
-        };
-        serverResponse = await (0, axios_1.default)(config);
+        const userMe = await fetchCurrentUser(cliVersion, token, superblocksBaseUrl);
+        const organization = userMe.organizations[0];
+        if (organization.agentType == types_1.AgentType.ONPREMISE && (0, flag_1.signingEnabled)(userMe.flagBootstrap)) {
+            const agentUrls = (0, utils_1.getAgentUrls)(userMe.agents, organization.agentType);
+            const socket = await (0, socket_1.connectToISocketRPCServer)({
+                agentUrls,
+                superblocksBaseUrl,
+                token,
+            });
+            const resp = await socket.call.v1.public.application.pushCommit({
+                applicationId,
+                apis: applicationConfig.apis,
+                application: applicationConfig.application,
+                branchName: branch,
+                commitId: applicationConfig.commitId,
+                commitMessage: applicationConfig.commitMessage,
+                page: applicationConfig.page,
+            });
+            socket.close();
+            return resp.data;
+        }
+        else {
+            const config = {
+                method: "post",
+                url: serverURL.toString(),
+                headers: {
+                    Authorization: "Bearer " + token,
+                    [CLI_VERSION_HEADER]: cliVersion,
+                    ...injectedHeaders,
+                },
+                data: applicationConfig,
+            };
+            serverResponse = await (0, axios_1.default)(config);
+        }
     }
     catch (e) {
         if (axios_1.default.isAxiosError(e)) {
@@ -412,17 +487,38 @@ async function pushApi({ cliVersion, apiId, token, superblocksBaseUrl, apiConfig
     const serverURL = new URL(`${BASE_SERVER_PUBLIC_API_URL}/apis/${apiId}/branches/${encodeURIComponent(branch)}/push`, superblocksBaseUrl);
     let serverResponse;
     try {
-        const config = {
-            method: "post",
-            url: serverURL.toString(),
-            headers: {
-                Authorization: "Bearer " + token,
-                [CLI_VERSION_HEADER]: cliVersion,
-                ...injectedHeaders,
-            },
-            data: apiConfig,
-        };
-        serverResponse = await (0, axios_1.default)(config);
+        const userMe = await fetchCurrentUser(cliVersion, token, superblocksBaseUrl);
+        const organization = userMe.organizations[0];
+        if (organization.agentType == types_1.AgentType.ONPREMISE && (0, flag_1.signingEnabled)(userMe.flagBootstrap)) {
+            const agentUrls = (0, utils_1.getAgentUrls)(userMe.agents, organization.agentType);
+            const socket = await (0, socket_1.connectToISocketRPCServer)({
+                agentUrls,
+                superblocksBaseUrl,
+                token,
+            });
+            const resp = await socket.call.v1.public.api.pushCommit({
+                apiId,
+                apiPb: apiConfig.apiPb,
+                branchName: branch,
+                commitId: apiConfig.commitId,
+                commitMessage: apiConfig.commitMessage,
+            });
+            socket.close();
+            return resp.data;
+        }
+        else {
+            const config = {
+                method: "post",
+                url: serverURL.toString(),
+                headers: {
+                    Authorization: "Bearer " + token,
+                    [CLI_VERSION_HEADER]: cliVersion,
+                    ...injectedHeaders,
+                },
+                data: apiConfig,
+            };
+            serverResponse = await (0, axios_1.default)(config);
+        }
     }
     catch (e) {
         if (axios_1.default.isAxiosError(e)) {

package/dist/flag.d.ts

@@ -0,0 +1,2 @@
+import { FlagBootstrap } from "./types";
+export declare const signingEnabled: (flags: FlagBootstrap) => boolean;

package/dist/flag.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.signingEnabled = void 0;
+const signingEnabled = (flags) => {
+    var _a;
+    return (_a = flags["ui.enable-resource-signing"]) !== null && _a !== void 0 ? _a : false;
+};
+exports.signingEnabled = signingEnabled;

package/dist/sdk.d.ts

@@ -1,5 +1,5 @@
 import { ComponentEvent, LocalGitRepoState, SuperblocksResourceType } from "@superblocksteam/util";
-import { ViewMode, PushApplicationWithCommitConfig, PushApiWithCommitConfig } from "./client";
+import { PushApiWithCommitConfig, PushApplicationWithCommitConfig, ViewMode } from "./client";
 export * from "./errors";
 export declare class SuperblocksSdk {
     token: string;
@@ -27,15 +27,15 @@ export declare class SuperblocksSdk {
     validateGitSetup(resourceId: string, resourceType: SuperblocksResourceType, event: ComponentEvent, localGitRepoState: LocalGitRepoState, injectedHeaders?: Record<string, string>): Promise<{
         branchName: string | null;
     }>;
-    registerComponents(applicationId: string, componentConfigs: Record<string, any>, branch: string | null, injectedHeaders?: Record<string, string>): Promise<any>;
-    uploadComponents(applicationId: string, componentConfigs: Record<string, any>, files: string[], branch: string | null): Promise<any>;
-    fetchCurrentUser(): Promise<any>;
+    registerComponents(applicationId: string, componentConfigs: Record<string, any>, branch: string | null, injectedHeaders: Record<string, string>): Promise<any>;
+    uploadComponents(applicationId: string, componentConfigs: Record<string, any>, files: string[], branch: string | null): Promise<void>;
+    fetchCurrentUser(): Promise<import("./types").UserMeDto>;
     pushApplication({ applicationId, applicationConfig, branch, headers, }: {
         applicationId: string;
         applicationConfig: PushApplicationWithCommitConfig;
         branch: string;
         headers?: Record<string, string>;
-    }): Promise<import("./client").ApplicationWrapper | undefined>;
+    }): Promise<import("./types").RemoteCommitDto | undefined>;
     pushApi({ apiId, apiConfig, branch, headers, }: {
         apiId: string;
         apiConfig: PushApiWithCommitConfig;

package/dist/socket/handlers.d.ts

@@ -0,0 +1,105 @@
+import { ApiToSign, ApiToVerify, AppToSign, AppToVerify, MethodHandlers, RemoteCommitDto, Signature } from "../types";
+type MethodSchema<Params, Response> = (params: Params) => Promise<Response>;
+export interface ClientMethods {
+    v1: {
+        signing: {
+            signApplication: MethodSchema<{
+                branchName: string;
+                toSign: AppToSign;
+            }, {
+                signature: Signature;
+            }>;
+            signApis: MethodSchema<{
+                branchName: string;
+                toSign: ApiToSign[];
+            }, {
+                signatures: Signature[];
+            }>;
+            verifyApplication: MethodSchema<{
+                branchName: string;
+                toVerify: AppToVerify;
+            }, {
+                ok: boolean;
+            }>;
+            verifyApi: MethodSchema<{
+                branchName: string;
+                toVerify: ApiToVerify[];
+            }, {
+                ok: boolean;
+            }>;
+        };
+    };
+}
+type ServerMethodSchema<Params, Response> = MethodSchema<Params, ResponseDto<Response>>;
+type ResponseDto<T> = {
+    responseMeta: ResponseMeta;
+    data: T;
+};
+export type ResponseMeta = {
+    status: number;
+    success: boolean;
+    error?: APIResponseError;
+};
+type APIResponseError = {
+    code: number;
+    message: string;
+};
+export interface ServerMethods {
+    v1: {
+        echo: MethodSchema<{
+            message: string;
+        }, {
+            message: string;
+        }>;
+        public: {
+            application: {
+                component: {
+                    register: ServerMethodSchema<{
+                        applicationId: string;
+                        branchName: string;
+                        cliVersion: string;
+                        componentEvent: string;
+                        components: Record<string, unknown>;
+                    }, {
+                        success: boolean;
+                    }>;
+                    update: ServerMethodSchema<{
+                        applicationId: string;
+                        branchName?: string;
+                        srcFiles: string[];
+                        buildFiles: string[];
+                        registeredComponents: Record<string, unknown>;
+                        cliVersion: string | undefined;
+                        componentBaseUrl: string;
+                        signingRequired: boolean;
+                    }, {
+                        success: boolean;
+                    }>;
+                };
+                pushCommit: ServerMethodSchema<{
+                    applicationId: string;
+                    branchName: string;
+                    commitId: string;
+                    commitMessage: string;
+                    application: Record<string, unknown>;
+                    page: Record<string, unknown>;
+                    apis: Record<string, unknown>[];
+                }, RemoteCommitDto>;
+            };
+            api: {
+                pushCommit: ServerMethodSchema<{
+                    apiId: string;
+                    branchName: string;
+                    commitId: string;
+                    commitMessage: string;
+                    apiPb: Record<string, unknown>;
+                }, RemoteCommitDto>;
+            };
+        };
+    };
+}
+export declare function createRequestHandlers({ agentUrls, token, }: {
+    token: string;
+    agentUrls: string[];
+}): MethodHandlers<ClientMethods, ServerMethods, unknown>;
+export {};

package/dist/socket/handlers.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createRequestHandlers = void 0;
+const signing_1 = require("./signing");
+function createRequestHandlers({ agentUrls, token, }) {
+    const requestHandlers = {
+        v1: {
+            signing: {
+                signApplication: [
+                    async ({ branchName, toSign, }) => {
+                        const signature = await (0, signing_1.signResource)({
+                            agentUrls,
+                            token: token,
+                            branchName,
+                            resource: {
+                                literal: {
+                                    data: toSign.rootHash,
+                                },
+                            },
+                        });
+                        return { signature: signature };
+                    },
+                ],
+                signApis: [
+                    async ({ branchName, toSign, }) => {
+                        const signatures = [];
+                        for (const { apiPb } of toSign) {
+                            const signature = await (0, signing_1.signResource)({
+                                agentUrls,
+                                token: token,
+                                branchName,
+                                resource: { api: apiPb },
+                            });
+                            signatures.push(signature);
+                        }
+                        return { signatures };
+                    },
+                ],
+                verifyApplication: [
+                    async ({ branchName, toVerify, }) => {
+                        try {
+                            await (0, signing_1.verifyResources)({
+                                agentUrls,
+                                token,
+                                branchName,
+                                resources: [
+                                    {
+                                        literal: {
+                                            data: toVerify.rootHash,
+                                            signature: toVerify.signature,
+                                        },
+                                    },
+                                ],
+                            });
+                            return { ok: true };
+                        }
+                        catch {
+                            return { ok: false };
+                        }
+                    },
+                ],
+                verifyApi: [
+                    async ({ branchName, toVerify, }) => {
+                        try {
+                            await (0, signing_1.verifyResources)({
+                                agentUrls,
+                                token,
+                                branchName,
+                                resources: toVerify.map(({ apiPb }) => ({
+                                    api: apiPb,
+                                })),
+                            });
+                            return { ok: true };
+                        }
+                        catch {
+                            return { ok: false };
+                        }
+                    },
+                ],
+            },
+        },
+    };
+    return requestHandlers;
+}
+exports.createRequestHandlers = createRequestHandlers;

package/dist/socket/index.d.ts

@@ -0,0 +1,27 @@
+/// <reference types="ws" />
+import WebSocket from "isomorphic-ws";
+import { ServerMethods } from "./handlers";
+export type StdISocketRPCClient = ISocketClient<ServerMethods>;
+export declare function connectToISocketRPCServer({ superblocksBaseUrl, agentUrls, token, }: {
+    superblocksBaseUrl: string;
+    agentUrls: string[];
+    token: string;
+}): Promise<StdISocketRPCClient>;
+export declare function connectISocket<CallableMethods, ImplementedMethods, RequestContext = never>(wsUrl: string, authorization: string | undefined, requestHandlers: MethodHandlers<ImplementedMethods, CallableMethods, RequestContext>): Promise<ISocketClient<CallableMethods>>;
+export declare function connectWebSocket(wsUrl: string): Promise<WebSocket>;
+type MethodHandler<Params, Result, PeerMethods, RequestContext> = (params: Params, peer: ISocketClient<PeerMethods>, ctx: RequestContext) => Promise<Result>;
+type MiddlewareHandler<Params, PeerMethods, RequestContext> = (params: Params, peerAuthorization: string | undefined, peer: ISocketClient<PeerMethods>, ctx: RequestContext) => Promise<void>;
+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;
+};
+type ISocketClient<Methods> = {
+    close: () => void;
+    call: ISocketClientMethodCall<Methods>;
+};
+export {};

package/dist/socket/index.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.connectWebSocket = exports.connectISocket = exports.connectToISocketRPCServer = void 0;
+const tslib_1 = require("tslib");
+const isomorphic_ws_1 = tslib_1.__importDefault(require("isomorphic-ws"));
+const handlers_1 = require("./handlers");
+const socket_1 = require("./socket");
+async function connectToISocketRPCServer({ superblocksBaseUrl, agentUrls, token, }) {
+    const requestHandlers = (0, handlers_1.createRequestHandlers)({
+        agentUrls,
+        token,
+    });
+    const authorization = `Bearer ${token}`;
+    const wsUrl = new URL("api/v1/rpc-ws", superblocksBaseUrl);
+    if (wsUrl.protocol === "http:") {
+        wsUrl.protocol = "ws:";
+    }
+    else if (wsUrl.protocol === "https:") {
+        wsUrl.protocol = "wss:";
+    }
+    if (wsUrl.host === "localhost:3000") {
+        wsUrl.host = "127.0.0.1:8080";
+    }
+    else if (wsUrl.hostname === "localhost") {
+        wsUrl.hostname = "127.0.0.1";
+    }
+    return await connectISocket(wsUrl.href, authorization, requestHandlers);
+}
+exports.connectToISocketRPCServer = connectToISocketRPCServer;
+// a subclass of ISocket that sends an auth token on the first request
+// this is useful for client-side sockets that need to authenticate
+// TODO(george): if we start using this for long-lived connections, we should add a way to refresh the token
+class ISocketWithClientAuth extends socket_1.ISocket {
+    constructor(ws, authorization, requestHandlers) {
+        super(ws, requestHandlers);
+        this.hasSentAuth = false;
+        this.authorization = authorization;
+    }
+    // override `request` from the base class to send `authorization` when appropriate
+    async request(method, params) {
+        // only send `authorization` on the first request
+        const authorization = this.hasSentAuth ? undefined : this.authorization;
+        const result = await super.request(method, params, authorization);
+        this.hasSentAuth = true;
+        return result;
+    }
+}
+async function connectISocket(wsUrl, authorization, requestHandlers) {
+    const ws = await connectWebSocket(wsUrl);
+    const isocket = new ISocketWithClientAuth(ws, authorization, requestHandlers);
+    return (0, socket_1.createISocketClient)(isocket);
+}
+exports.connectISocket = connectISocket;
+function connectWebSocket(wsUrl) {
+    return new Promise((resolve, reject) => {
+        const ws = new isomorphic_ws_1.default(wsUrl);
+        ws.addEventListener("open", () => {
+            // Resolve the promise with the WebSocket instance when the connection is open
+            resolve(ws);
+        });
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-ignore
+        ws.addEventListener("error", (error) => {
+            // Reject the promise if there's an error
+            reject(error);
+        });
+    });
+}
+exports.connectWebSocket = connectWebSocket;

package/dist/socket/signing.d.ts

@@ -0,0 +1,13 @@
+import { ApiResource, GenericResource, Signature } from "../types";
+export declare function signResource({ token, branchName, resource, agentUrls, }: {
+    token: string;
+    branchName: string;
+    resource: ApiResource | GenericResource;
+    agentUrls: string[];
+}): Promise<Signature>;
+export declare function verifyResources({ agentUrls, token, branchName, resources, }: {
+    resources: Array<GenericResource | ApiResource>;
+    token: string;
+    branchName: string;
+    agentUrls: string[];
+}): Promise<void>;