@bananalink-test/agent 1.0.1

package/dist/index.d.mts

@@ -0,0 +1,175 @@
+import { Agent, Agent as Agent$1, EthSendTransactionParams, EthSendTransactionParams as EthSendTransactionParams$1, EthSendTransactionResult, TransportHandle } from "@bananalink-test/sdk-core";
+
+//#region src/types/ConnectOpts.d.ts
+type ConnectOpts = {
+  accessToken?: string;
+};
+//#endregion
+//#region src/types/JwtPayload.d.ts
+type JwtPayload = {
+  agentId: string;
+  jwt: string;
+};
+//#endregion
+//#region src/types/RequestMap.d.ts
+type RequestMap = {
+  eth_sendTransaction: {
+    params: [EthSendTransactionParams$1];
+    result: string;
+  };
+};
+//#endregion
+//#region src/types/Request.d.ts
+type Request = keyof RequestMap;
+//#endregion
+//#region src/types/RequestParams.d.ts
+type RequestParams<T extends keyof RequestMap> = RequestMap[T]['params'];
+//#endregion
+//#region src/types/RequestResult.d.ts
+type RequestResult<T extends keyof RequestMap> = RequestMap[T]['result'];
+//#endregion
+//#region src/types/SessionClaims.d.ts
+type SessionClaims = {
+  accessToken: string;
+};
+//#endregion
+//#region src/core/BananalinkSession.d.ts
+declare class BananalinkSession {
+  readonly sessionClaims: SessionClaims;
+  private readonly ws;
+  private readonly apiUrl;
+  private static readonly REQUEST_TIMEOUT_MS;
+  private static readonly CREATE_DAPP_MESSAGE_MAX_ATTEMPTS;
+  private static readonly CREATE_DAPP_MESSAGE_BASE_DELAY_MS;
+  private readonly pendingRequests;
+  private readonly stopListening;
+  private readonly stopListeningOnClose;
+  private closed;
+  private static readonly RESULT_HANDLERS;
+  constructor(sessionClaims: SessionClaims, ws: TransportHandle, apiUrl: string);
+  request<T extends Request>({
+    method,
+    params,
+    timeoutMs
+  }: {
+    method: T;
+    params?: RequestParams<T>;
+    timeoutMs?: number;
+  }): Promise<RequestResult<T>>;
+  close(): void;
+  private handleMessageResponse;
+  private cleanup;
+  private rejectAllPendingRequests;
+}
+//#endregion
+//#region src/core/BananalinkConnection.d.ts
+type BananalinkAgentJwt = {
+  jwtPayload: JwtPayload;
+  accessToken: string;
+} | undefined;
+declare class BananalinkConnection {
+  private static readonly AUTH_TIMEOUT_MILLIS;
+  private static readonly BIND_RESPONSE_TIMEOUT_MILLIS;
+  private readonly apiUrl;
+  private readonly wsUrl;
+  private readonly jwt;
+  private readonly agentPairingCode;
+  private pendingSessionPromise;
+  private pendingSessionAbortController;
+  constructor(opts: {
+    apiUrl: string;
+    wsUrl: string;
+    jwt: BananalinkAgentJwt;
+    agentPairingCode: string | null;
+  });
+  get connectionUrl(): string;
+  abortPendingSession(): void;
+  getSession(): Promise<BananalinkSession>;
+  private openSession;
+  private resumeSession;
+  private waitForAuthorization;
+  private getTransportHandle;
+  private bind;
+}
+//#endregion
+//#region src/core/BananalinkAgent.d.ts
+declare class BananalinkAgent {
+  private readonly apiUrl;
+  private readonly wsUrl;
+  private readonly jwks;
+  private readonly agent;
+  private static readonly DEFAULT_BANANALINK_API_URL;
+  private static readonly DEFAULT_BANANALINK_WS_URL;
+  constructor(config: {
+    apiUrl?: string;
+    wsUrl?: string;
+    agent: Agent$1;
+  });
+  connect(opts?: ConnectOpts): Promise<BananalinkConnection>;
+  private getJwtPayload;
+  private pairAgent;
+}
+//#endregion
+//#region src/errors/BananalinkError.d.ts
+declare class BananalinkError extends Error {
+  constructor(message: string, options?: ErrorOptions);
+}
+//#endregion
+//#region src/errors/AgentApiError.d.ts
+declare class AgentApiError extends BananalinkError {
+  readonly statusCode: number;
+  constructor(message: string, statusCode: number);
+}
+//#endregion
+//#region src/errors/ConnectionRejectedError.d.ts
+declare class ConnectionRejectedError extends BananalinkError {
+  constructor();
+}
+//#endregion
+//#region src/errors/ConnectionTimeoutError.d.ts
+declare class ConnectionTimeoutError extends BananalinkError {
+  constructor();
+}
+//#endregion
+//#region src/errors/InvalidConfigError.d.ts
+declare class InvalidConfigError extends BananalinkError {
+  constructor(message: string);
+}
+//#endregion
+//#region src/errors/InvalidConnectionStateError.d.ts
+declare class InvalidConnectionStateError extends BananalinkError {
+  constructor(message: string);
+}
+//#endregion
+//#region src/errors/InvalidJwtError.d.ts
+declare class InvalidJwtError extends BananalinkError {
+  constructor();
+}
+//#endregion
+//#region src/errors/PendingSessionAbortedError.d.ts
+declare class PendingSessionAbortedError extends BananalinkError {
+  constructor();
+}
+//#endregion
+//#region src/errors/RequestRejectedError.d.ts
+declare class RequestRejectedError extends BananalinkError {
+  readonly messageId: string;
+  constructor(messageId: string);
+}
+//#endregion
+//#region src/errors/RequestTimeoutError.d.ts
+declare class RequestTimeoutError extends BananalinkError {
+  readonly method: Request;
+  constructor(method: Request);
+}
+//#endregion
+//#region src/errors/SessionClosedError.d.ts
+declare class SessionClosedError extends BananalinkError {
+  constructor();
+}
+//#endregion
+//#region src/utils/displayBananalinkQR.d.ts
+declare function displayBananalinkQR(url: string): Promise<string>;
+//#endregion
+export { type Agent, AgentApiError, BananalinkAgent, BananalinkConnection, BananalinkError, BananalinkSession, type ConnectOpts, ConnectionRejectedError, ConnectionTimeoutError, type EthSendTransactionParams, type EthSendTransactionResult, InvalidConfigError, InvalidConnectionStateError, InvalidJwtError, PendingSessionAbortedError, type Request, type RequestMap, type RequestParams, RequestRejectedError, type RequestResult, RequestTimeoutError, SessionClosedError, displayBananalinkQR };
+//# sourceMappingURL=index.d.mts.map

package/dist/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","names":[],"sources":["../src/types/ConnectOpts.ts","../src/types/JwtPayload.ts","../src/types/RequestMap.ts","../src/types/Request.ts","../src/types/RequestParams.ts","../src/types/RequestResult.ts","../src/types/SessionClaims.ts","../src/core/BananalinkSession.ts","../src/core/BananalinkConnection.ts","../src/core/BananalinkAgent.ts","../src/errors/BananalinkError.ts","../src/errors/AgentApiError.ts","../src/errors/ConnectionRejectedError.ts","../src/errors/ConnectionTimeoutError.ts","../src/errors/InvalidConfigError.ts","../src/errors/InvalidConnectionStateError.ts","../src/errors/InvalidJwtError.ts","../src/errors/PendingSessionAbortedError.ts","../src/errors/RequestRejectedError.ts","../src/errors/RequestTimeoutError.ts","../src/errors/SessionClosedError.ts","../src/utils/displayBananalinkQR.ts"],"mappings":"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"}

package/dist/index.mjs

@@ -0,0 +1,439 @@
+import { createRemoteJWKSet, jwtVerify } from "jose";
+import { BindTransportError, bindTransport, connectWebSocket, createReconnectingTransport, isAuthorizedMessage, isMessageResponseMessage, isRejectedMessage, waitForTransportEvent, withBackoff } from "@bananalink-test/sdk-core";
+import QRCode from "qrcode";
+
+//#region src/errors/BananalinkError.ts
+var BananalinkError = class extends Error {
+	constructor(message, options) {
+		super(message, options);
+		this.name = "BananalinkError";
+	}
+};
+
+//#endregion
+//#region src/errors/AgentApiError.ts
+var AgentApiError = class extends BananalinkError {
+	constructor(message, statusCode) {
+		super(message);
+		this.statusCode = statusCode;
+		this.name = "AgentApiError";
+	}
+};
+
+//#endregion
+//#region src/api/createAgentPairingRequest.ts
+function isCreateAgentPairingResponse(body) {
+	return typeof body === "object" && body !== null && "pairingCode" in body;
+}
+async function createAgentPairingRequest(apiUrl, params) {
+	const response = await fetch(`${apiUrl}/agents/pairings`, {
+		headers: { "Content-Type": "application/json" },
+		method: "POST",
+		body: JSON.stringify(params)
+	});
+	if (response.ok) {
+		const body = await response.json().catch(() => {
+			throw new AgentApiError("Invalid JSON response from bananalink API", response.status);
+		});
+		if (!isCreateAgentPairingResponse(body)) throw new AgentApiError("Unexpected response shape from bananalink API", response.status);
+		return body;
+	}
+	throw new AgentApiError("Failed to create agent pairing request", response.status);
+}
+
+//#endregion
+//#region src/errors/InvalidConfigError.ts
+var InvalidConfigError = class extends BananalinkError {
+	constructor(message) {
+		super(message);
+		this.name = "InvalidConfigError";
+	}
+};
+
+//#endregion
+//#region src/errors/InvalidJwtError.ts
+var InvalidJwtError = class extends BananalinkError {
+	constructor() {
+		super("Invalid Bananalink agent jwt");
+	}
+};
+
+//#endregion
+//#region src/jwt/createBananalinkJwks.ts
+function createBananalinkJwks(apiUrl) {
+	return createRemoteJWKSet(new URL(`${apiUrl}/.well-known/jwks.json`));
+}
+
+//#endregion
+//#region src/jwt/verifyJwt.ts
+async function verifyJwt(jwt, jwks) {
+	try {
+		const { payload } = await jwtVerify(jwt, jwks, {
+			algorithms: ["ES256"],
+			issuer: "bananalink",
+			requiredClaims: ["sub", "aud"]
+		});
+		return {
+			agentId: Array.isArray(payload.aud) ? payload.aud[0] : payload.aud,
+			jwt
+		};
+	} catch {
+		return null;
+	}
+}
+
+//#endregion
+//#region src/utils/isValidUrl.ts
+function isValidUrl(url, protocols) {
+	try {
+		const parsed = new URL(url);
+		return protocols.includes(parsed.protocol.replace(":", ""));
+	} catch {
+		return false;
+	}
+}
+
+//#endregion
+//#region src/errors/ConnectionRejectedError.ts
+var ConnectionRejectedError = class extends BananalinkError {
+	constructor() {
+		super("Agent connection attempt was rejected by the hub");
+		this.name = "ConnectionRejectedError";
+	}
+};
+
+//#endregion
+//#region src/errors/ConnectionTimeoutError.ts
+var ConnectionTimeoutError = class extends BananalinkError {
+	constructor() {
+		super("Agent connection attempt timed out");
+		this.name = "ConnectionTimeoutError";
+	}
+};
+
+//#endregion
+//#region src/errors/InvalidConnectionStateError.ts
+var InvalidConnectionStateError = class extends BananalinkError {
+	constructor(message) {
+		super(message);
+		this.name = "InvalidConnectionStateError";
+	}
+};
+
+//#endregion
+//#region src/errors/PendingSessionAbortedError.ts
+var PendingSessionAbortedError = class extends BananalinkError {
+	constructor() {
+		super("Pending session was intentionally aborted");
+		this.name = "PendingSessionAbortedError";
+	}
+};
+
+//#endregion
+//#region src/api/createAgentMessage.ts
+function isCreateAgentMessageResponse(body) {
+	return typeof body === "object" && body !== null && "messageId" in body && typeof body.messageId === "string";
+}
+async function createAgentMessage(apiUrl, accessToken, params) {
+	const response = await fetch(`${apiUrl}/agents/messages`, {
+		method: "POST",
+		headers: {
+			Authorization: `Bearer ${accessToken}`,
+			"Content-Type": "application/json"
+		},
+		body: JSON.stringify(params)
+	});
+	if (response.ok) {
+		const body = await response.json().catch(() => {
+			throw new AgentApiError("Invalid JSON response from bananalink API", response.status);
+		});
+		if (!isCreateAgentMessageResponse(body)) throw new AgentApiError("Unexpected response shape from bananalink API", response.status);
+		return body;
+	}
+	throw new AgentApiError("Failed to create agent message", response.status);
+}
+
+//#endregion
+//#region src/errors/RequestRejectedError.ts
+var RequestRejectedError = class extends BananalinkError {
+	constructor(messageId) {
+		super(`Request rejected by hub (messageId: ${messageId})`);
+		this.messageId = messageId;
+		this.name = "RequestRejectedError";
+	}
+};
+
+//#endregion
+//#region src/errors/RequestTimeoutError.ts
+var RequestTimeoutError = class extends BananalinkError {
+	constructor(method) {
+		super(`Timeout reached for request ${method}`);
+		this.method = method;
+	}
+};
+
+//#endregion
+//#region src/errors/SessionClosedError.ts
+var SessionClosedError = class extends BananalinkError {
+	constructor() {
+		super("Session is closed");
+	}
+};
+
+//#endregion
+//#region src/core/BananalinkSession.ts
+var BananalinkSession = class BananalinkSession {
+	static REQUEST_TIMEOUT_MS = 600 * 1e3;
+	static CREATE_DAPP_MESSAGE_MAX_ATTEMPTS = 3;
+	static CREATE_DAPP_MESSAGE_BASE_DELAY_MS = 1e3;
+	pendingRequests = /* @__PURE__ */ new Map();
+	stopListening;
+	stopListeningOnClose;
+	closed;
+	static RESULT_HANDLERS = { eth_sendTransaction: (result) => {
+		if (typeof result === "object" && result !== null && "txHash" in result && typeof result.txHash === "string") return result.txHash;
+		throw new BananalinkError(`Unexpected eth_sendTransaction result: ${result}`);
+	} };
+	constructor(sessionClaims, ws, apiUrl) {
+		this.sessionClaims = sessionClaims;
+		this.ws = ws;
+		this.apiUrl = apiUrl;
+		this.stopListening = this.ws.onMessage((payload) => {
+			if (isMessageResponseMessage(payload)) this.handleMessageResponse(payload);
+		});
+		this.stopListeningOnClose = this.ws.onClose(() => {
+			this.cleanup();
+			this.closed = true;
+		});
+		this.closed = false;
+	}
+	async request({ method, params, timeoutMs = BananalinkSession.REQUEST_TIMEOUT_MS }) {
+		if (this.closed) throw new SessionClosedError();
+		const { messageId } = await withBackoff(async () => await createAgentMessage(this.apiUrl, this.sessionClaims.accessToken, {
+			method,
+			payload: params
+		}), BananalinkSession.CREATE_DAPP_MESSAGE_MAX_ATTEMPTS, BananalinkSession.CREATE_DAPP_MESSAGE_BASE_DELAY_MS);
+		if (this.closed) throw new SessionClosedError();
+		return new Promise((resolve, reject) => {
+			let timeout;
+			if (timeoutMs > 0) timeout = setTimeout(() => {
+				this.pendingRequests.delete(messageId);
+				reject(new RequestTimeoutError(method));
+			}, timeoutMs);
+			this.pendingRequests.set(messageId, {
+				timeout,
+				handle: (messageResponse) => {
+					if (messageResponse.status === "rejected") {
+						reject(new RequestRejectedError(messageId));
+						return;
+					}
+					const resultHandler = BananalinkSession.RESULT_HANDLERS[method];
+					try {
+						resolve(resultHandler(messageResponse.payloadResponse));
+					} catch (error) {
+						reject(new BananalinkError(`Failed resolving request response, ${error}`));
+					}
+				},
+				reject
+			});
+		});
+	}
+	close() {
+		this.cleanup();
+		if (!this.ws.closed) this.ws.close();
+		this.closed = true;
+	}
+	handleMessageResponse(messageResponseMessage) {
+		const pending = this.pendingRequests.get(messageResponseMessage.msgId);
+		if (!pending) return;
+		this.pendingRequests.delete(messageResponseMessage.msgId);
+		clearTimeout(pending.timeout);
+		pending.handle(messageResponseMessage);
+	}
+	cleanup() {
+		this.rejectAllPendingRequests();
+		this.stopListening();
+		this.stopListeningOnClose();
+	}
+	rejectAllPendingRequests() {
+		for (const [, pending] of this.pendingRequests) {
+			clearTimeout(pending.timeout);
+			pending.reject(/* @__PURE__ */ new Error("Pending requests rejected"));
+		}
+		this.pendingRequests.clear();
+	}
+};
+
+//#endregion
+//#region src/core/BananalinkConnection.ts
+var BananalinkConnection = class BananalinkConnection {
+	static AUTH_TIMEOUT_MILLIS = 600 * 1e3;
+	static BIND_RESPONSE_TIMEOUT_MILLIS = 20 * 1e3;
+	apiUrl;
+	wsUrl;
+	jwt;
+	agentPairingCode;
+	pendingSessionPromise = null;
+	pendingSessionAbortController = null;
+	constructor(opts) {
+		this.apiUrl = opts.apiUrl;
+		this.wsUrl = opts.wsUrl;
+		this.jwt = opts.jwt;
+		this.agentPairingCode = opts.agentPairingCode;
+		if (!this.agentPairingCode && !this.jwt) throw new InvalidConnectionStateError("Cannot get session without authorizing agent or providing a valid JWT");
+	}
+	get connectionUrl() {
+		if (!this.agentPairingCode) throw new InvalidConnectionStateError("Cannot get connection URL without a pairing code");
+		return `bananalink://?code=${encodeURIComponent(this.agentPairingCode)}`;
+	}
+	abortPendingSession() {
+		this.pendingSessionAbortController?.abort();
+	}
+	async getSession() {
+		if (this.pendingSessionPromise) return this.pendingSessionPromise;
+		this.pendingSessionAbortController = new AbortController();
+		this.pendingSessionPromise = (this.jwt ? this.resumeSession(this.jwt, this.pendingSessionAbortController.signal) : this.waitForAuthorization(this.pendingSessionAbortController.signal)).finally(() => {
+			this.pendingSessionPromise = null;
+			this.pendingSessionAbortController = null;
+		});
+		return this.pendingSessionPromise;
+	}
+	async openSession(getSessionClaims, abortSignal) {
+		const transportHandle = await this.getTransportHandle(this.agentPairingCode);
+		const onAbort = () => transportHandle.close();
+		abortSignal.addEventListener("abort", onAbort, { once: true });
+		if (abortSignal.aborted) {
+			transportHandle.close();
+			throw new PendingSessionAbortedError();
+		}
+		try {
+			const sessionClaims = await getSessionClaims(transportHandle);
+			await this.bind(transportHandle, sessionClaims.accessToken, abortSignal);
+			return new BananalinkSession(sessionClaims, createReconnectingTransport(transportHandle, {
+				reconnectTransport: async () => this.getTransportHandle(null),
+				onReconnect: async (th) => this.bind(th, sessionClaims.accessToken),
+				maxReconnectAttempts: 5,
+				baseDelayReconnectMs: 1e3
+			}), this.apiUrl);
+		} catch (error) {
+			transportHandle.close();
+			throw error;
+		} finally {
+			abortSignal.removeEventListener("abort", onAbort);
+		}
+	}
+	async resumeSession(jwt, abortSignal) {
+		return await this.openSession(async () => ({
+			...jwt.jwtPayload,
+			accessToken: jwt.accessToken
+		}), abortSignal);
+	}
+	async waitForAuthorization(abortSignal) {
+		return await this.openSession(async (transportHandle) => await waitForTransportEvent(transportHandle, {
+			onMessage: (payload, resolve, reject) => {
+				if (isAuthorizedMessage(payload)) resolve(payload);
+				if (isRejectedMessage(payload)) reject(new ConnectionRejectedError());
+			},
+			timeoutMs: BananalinkConnection.AUTH_TIMEOUT_MILLIS,
+			createTimeoutError: () => new ConnectionTimeoutError(),
+			createClosedError: () => new BananalinkError("Connection closed unexpectedly"),
+			abortSignal,
+			createAbortError: () => new PendingSessionAbortedError()
+		}), abortSignal);
+	}
+	async getTransportHandle(agentPairingCode) {
+		const url = `${this.wsUrl}${agentPairingCode != null ? `?code=${encodeURIComponent(agentPairingCode)}` : ""}`;
+		try {
+			return await connectWebSocket({
+				url,
+				pingIntervalMs: 3e4,
+				pongTimeoutMs: 5e3,
+				maxReconnectAttempts: 0
+			});
+		} catch (error) {
+			throw new BananalinkError("Unable to establish agent websocket connection", { cause: error });
+		}
+	}
+	async bind(ws, accessToken, abortSignal) {
+		try {
+			await bindTransport(ws, accessToken, {
+				timeoutMs: BananalinkConnection.BIND_RESPONSE_TIMEOUT_MILLIS,
+				createTimeoutError: () => new ConnectionTimeoutError(),
+				createClosedError: () => new BananalinkError("Connection closed unexpectedly"),
+				abortSignal,
+				createAbortError: () => new PendingSessionAbortedError()
+			});
+		} catch (error) {
+			if (error instanceof BindTransportError) throw new InvalidJwtError();
+			throw error;
+		}
+	}
+};
+
+//#endregion
+//#region src/core/BananalinkAgent.ts
+var BananalinkAgent = class BananalinkAgent {
+	apiUrl;
+	wsUrl;
+	jwks;
+	agent;
+	static DEFAULT_BANANALINK_API_URL = "https://api.dev.banana.link";
+	static DEFAULT_BANANALINK_WS_URL = "wss://ws.dev.banana.link";
+	constructor(config) {
+		this.apiUrl = config.apiUrl ?? BananalinkAgent.DEFAULT_BANANALINK_API_URL;
+		this.wsUrl = config.wsUrl ?? BananalinkAgent.DEFAULT_BANANALINK_WS_URL;
+		if (!isValidUrl(this.apiUrl, ["http", "https"])) throw new InvalidConfigError(`Invalid apiUrl: "${this.apiUrl}". Must use http or https.`);
+		if (!isValidUrl(this.wsUrl, ["ws", "wss"])) throw new InvalidConfigError(`Invalid wsUrl: "${this.wsUrl}". Must use ws or wss.`);
+		this.agent = config.agent;
+		this.jwks = createBananalinkJwks(this.apiUrl);
+	}
+	async connect(opts) {
+		const accessToken = opts?.accessToken;
+		if (!accessToken) {
+			const { pairingCode } = await this.pairAgent();
+			return new BananalinkConnection({
+				jwt: void 0,
+				agentPairingCode: pairingCode,
+				apiUrl: this.apiUrl,
+				wsUrl: this.wsUrl
+			});
+		}
+		const jwtPayload = await this.getJwtPayload(accessToken);
+		if (!jwtPayload) throw new InvalidJwtError();
+		return new BananalinkConnection({
+			jwt: {
+				jwtPayload,
+				accessToken
+			},
+			agentPairingCode: null,
+			apiUrl: this.apiUrl,
+			wsUrl: this.wsUrl
+		});
+	}
+	async getJwtPayload(accessToken) {
+		return await verifyJwt(accessToken, this.jwks);
+	}
+	async pairAgent() {
+		return await createAgentPairingRequest(this.apiUrl, this.agent);
+	}
+};
+
+//#endregion
+//#region src/errors/InvalidUrlError.ts
+var InvalidUrlError = class extends BananalinkError {
+	constructor(url) {
+		super(`${url} is not a valid url`);
+		this.url = url;
+	}
+};
+
+//#endregion
+//#region src/utils/displayBananalinkQR.ts
+async function displayBananalinkQR(url) {
+	if (!isValidUrl(url, ["bananalink"])) throw new InvalidUrlError(url);
+	return QRCode.toDataURL(url);
+}
+
+//#endregion
+export { AgentApiError, BananalinkAgent, BananalinkConnection, BananalinkError, BananalinkSession, ConnectionRejectedError, ConnectionTimeoutError, InvalidConfigError, InvalidConnectionStateError, InvalidJwtError, PendingSessionAbortedError, RequestRejectedError, RequestTimeoutError, SessionClosedError, displayBananalinkQR };
+//# sourceMappingURL=index.mjs.map