@canister-software/consensus-cli 0.1.0-beta.3 → 0.1.0-beta.4

package/dist/proxy-client.js

@@ -0,0 +1,297 @@
+import { AsyncLocalStorage } from "async_hooks";
+const DEFAULT_SERVER_URL = process.env.CONSENSUS_SERVER_URL || "https://consensus.canister.software";
+class ProxyClientError extends Error {
+    status;
+    data;
+}
+const proxyFetchContext = new AsyncLocalStorage();
+let interceptorInstalled = false;
+let passthroughFetch = typeof globalThis.fetch === "function" ? globalThis.fetch.bind(globalThis) : null;
+function trimTrailingSlash(value) {
+    return String(value || "").replace(/\/+$/, "");
+}
+function normalizePath(value) {
+    const path = String(value || "/").split("?")[0] || "/";
+    if (path === "/")
+        return "/";
+    const normalized = path.replace(/\/+$/, "");
+    return normalized || "/";
+}
+function normalizeHeaders(headers) {
+    if (!headers)
+        return {};
+    if (typeof Headers !== "undefined" && headers instanceof Headers) {
+        return Object.fromEntries(headers.entries());
+    }
+    if (Array.isArray(headers)) {
+        return Object.fromEntries(headers.map(([key, value]) => [String(key), String(value)]));
+    }
+    const result = {};
+    for (const [key, value] of Object.entries(headers)) {
+        if (typeof value === "undefined" || value === null)
+            continue;
+        result[key] = String(value);
+    }
+    return result;
+}
+function pathMatches(pathname, route, matchSubroutes = false) {
+    const requestPath = normalizePath(pathname);
+    const configuredRoute = normalizePath(route);
+    if (requestPath === configuredRoute)
+        return true;
+    if (!matchSubroutes)
+        return false;
+    if (configuredRoute === "/")
+        return true;
+    return requestPath.startsWith(`${configuredRoute}/`);
+}
+function shouldProxyPath(pathname, options) {
+    const mode = options.mode === "exclusive" ? "exclusive" : "inclusive";
+    const routes = Array.isArray(options.routes) ? options.routes : [];
+    const matchSubroutes = Boolean(options.matchSubroutes);
+    const matched = routes.some((route) => pathMatches(pathname, route, matchSubroutes));
+    return mode === "exclusive" ? matched : !matched;
+}
+function controlHeadersFromOptions(options) {
+    const headers = {};
+    if (typeof options.cache_ttl !== "undefined" && options.cache_ttl !== null) {
+        headers["x-cache-ttl"] = String(options.cache_ttl);
+    }
+    if (options.verbose === true) {
+        headers["x-verbose"] = "true";
+    }
+    if (typeof options.node_region === "string" && options.node_region.trim()) {
+        headers["x-node-region"] = options.node_region.trim();
+    }
+    if (typeof options.node_domain === "string" && options.node_domain.trim()) {
+        headers["x-node-domain"] = options.node_domain.trim();
+    }
+    if (typeof options.node_exclude === "string" && options.node_exclude.trim()) {
+        headers["x-node-exclude"] = options.node_exclude.trim();
+    }
+    return headers;
+}
+function parseMaybeJson(text) {
+    if (!text)
+        return null;
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return text;
+    }
+}
+function normalizeBody(body, headers) {
+    if (typeof body === "undefined" || body === null)
+        return undefined;
+    if (typeof body === "string")
+        return body;
+    if (typeof body === "number" || typeof body === "boolean")
+        return body;
+    if (typeof URLSearchParams !== "undefined" && body instanceof URLSearchParams) {
+        if (!headers["content-type"] && !headers["Content-Type"]) {
+            headers["content-type"] = "application/x-www-form-urlencoded;charset=UTF-8";
+        }
+        return body.toString();
+    }
+    if (typeof Buffer !== "undefined" && Buffer.isBuffer(body)) {
+        return body.toString("utf8");
+    }
+    if (body instanceof ArrayBuffer || ArrayBuffer.isView(body)) {
+        const bytes = body instanceof ArrayBuffer
+            ? new Uint8Array(body)
+            : new Uint8Array(body.buffer, body.byteOffset, body.byteLength);
+        if (typeof Buffer !== "undefined")
+            return Buffer.from(bytes).toString("utf8");
+        return new TextDecoder().decode(bytes);
+    }
+    if (typeof FormData !== "undefined" && body instanceof FormData) {
+        throw new Error("FormData request bodies are not supported by ProxyClient");
+    }
+    if (typeof body === "object") {
+        if (!headers["content-type"] && !headers["Content-Type"]) {
+            headers["content-type"] = "application/json";
+        }
+        return body;
+    }
+    throw new Error(`Unsupported request body type: ${typeof body}`);
+}
+async function buildProxyPayload(input, init = {}, controlHeaders) {
+    let targetUrl;
+    let method = "GET";
+    let headers = {};
+    let body;
+    if (typeof Request !== "undefined" && input instanceof Request) {
+        targetUrl = input.url;
+        method = input.method || method;
+        headers = normalizeHeaders(input.headers);
+        if (!("body" in init) && method !== "GET" && method !== "HEAD") {
+            const raw = await input.clone().text();
+            if (raw.length > 0)
+                body = raw;
+        }
+    }
+    else if (typeof input === "string" || input instanceof URL) {
+        targetUrl = String(input);
+    }
+    else {
+        throw new Error("ProxyClient fetch input must be URL string, URL, or Request");
+    }
+    method = String(init.method || method || "GET").toUpperCase();
+    headers = {
+        ...controlHeaders,
+        ...headers,
+        ...normalizeHeaders(init.headers),
+    };
+    if ("body" in init) {
+        body = init.body;
+    }
+    const normalizedBody = normalizeBody(body, headers);
+    return {
+        target_url: targetUrl,
+        method,
+        headers,
+        ...(typeof normalizedBody !== "undefined" ? { body: normalizedBody } : {}),
+    };
+}
+function toProxyResult(response, data) {
+    if (data && typeof data === "object" && "status" in data && "data" in data) {
+        const maybe = data;
+        return {
+            status: Number(maybe.status) || response.status || 200,
+            statusText: maybe.statusText || response.statusText || "",
+            headers: maybe.headers || {},
+            data: maybe.data,
+            meta: maybe.meta ?? null,
+        };
+    }
+    return {
+        status: response.status || 500,
+        statusText: response.statusText || "",
+        headers: {},
+        data,
+        meta: null,
+    };
+}
+function toFetchResponse(proxyResult, requestUrl) {
+    const headers = new Headers(proxyResult.headers || {});
+    const payload = proxyResult.data;
+    const body = payload === null || typeof payload === "undefined"
+        ? null
+        : typeof payload === "string"
+            ? payload
+            : JSON.stringify(payload);
+    if (payload !== null &&
+        typeof payload === "object" &&
+        !headers.has("content-type")) {
+        headers.set("content-type", "application/json");
+    }
+    const response = new Response(body, {
+        status: proxyResult.status,
+        statusText: proxyResult.statusText || "",
+        headers,
+    });
+    Object.defineProperty(response, "consensus", {
+        value: {
+            request_url: requestUrl,
+            meta: proxyResult.meta || null,
+        },
+        enumerable: false,
+        configurable: false,
+        writable: false,
+    });
+    return response;
+}
+function ensureInterceptorInstalled() {
+    if (interceptorInstalled)
+        return;
+    if (typeof globalThis.fetch === "function") {
+        passthroughFetch = globalThis.fetch.bind(globalThis);
+    }
+    if (!passthroughFetch) {
+        throw new Error("Global fetch is unavailable; use strategy: 'manual' or polyfill fetch.");
+    }
+    globalThis.fetch = ((input, init) => {
+        const state = proxyFetchContext.getStore();
+        if (state?.proxyFetch)
+            return state.proxyFetch(input, init);
+        return passthroughFetch(input, init);
+    });
+    interceptorInstalled = true;
+}
+function currentPassthroughFetch() {
+    if (passthroughFetch)
+        return passthroughFetch;
+    if (typeof globalThis.fetch === "function") {
+        passthroughFetch = globalThis.fetch.bind(globalThis);
+    }
+    return passthroughFetch;
+}
+export function ProxyClient(fetchWithPayment, options = {}) {
+    if (typeof fetchWithPayment !== "function") {
+        throw new TypeError("ProxyClient requires fetchWithPayment as the first argument");
+    }
+    const strategy = options.strategy === "manual" ? "manual" : "auto";
+    const serverUrl = trimTrailingSlash(DEFAULT_SERVER_URL);
+    const proxyEndpoint = `${serverUrl}/proxy`;
+    const baseControlHeaders = controlHeadersFromOptions(options);
+    async function requestProxy(payload) {
+        const response = await fetchWithPayment(proxyEndpoint, {
+            method: "POST",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify(payload),
+        });
+        const raw = await response.text();
+        const parsed = parseMaybeJson(raw);
+        if (!response.ok && !(parsed && typeof parsed === "object" && "status" in parsed)) {
+            const message = parsed?.message ||
+                parsed?.error ||
+                `Proxy request failed (${response.status})`;
+            const error = new ProxyClientError(message);
+            error.status = response.status;
+            error.data = parsed;
+            throw error;
+        }
+        return toProxyResult(response, parsed);
+    }
+    async function proxiedFetch(input, init = {}, perRequestOptions = {}) {
+        const controlHeaders = {
+            ...baseControlHeaders,
+            ...controlHeadersFromOptions(perRequestOptions),
+        };
+        const payload = await buildProxyPayload(input, init, controlHeaders);
+        const proxyResult = await requestProxy(payload);
+        const requestUrl = typeof Request !== "undefined" && input instanceof Request ? input.url : String(input);
+        return toFetchResponse(proxyResult, requestUrl);
+    }
+    async function proxiedRequest(payload = {}, perRequestOptions = {}) {
+        const controlHeaders = {
+            ...baseControlHeaders,
+            ...controlHeadersFromOptions(perRequestOptions),
+            ...normalizeHeaders(payload.headers),
+        };
+        return requestProxy({
+            target_url: String(payload.target_url || ""),
+            method: String(payload.method || "GET").toUpperCase(),
+            headers: controlHeaders,
+            ...(typeof payload.body !== "undefined" ? { body: payload.body } : {}),
+        });
+    }
+    return (req, _res, next) => {
+        const routePath = req?.path || req?.url || "/";
+        const shouldProxy = shouldProxyPath(routePath, options);
+        req.consensus = {
+            strategy,
+            shouldProxy,
+            fetch: proxiedFetch,
+            request: proxiedRequest,
+            passthroughFetch: currentPassthroughFetch(),
+        };
+        if (strategy !== "auto") {
+            next();
+            return;
+        }
+        ensureInterceptorInstalled();
+        proxyFetchContext.run({ proxyFetch: shouldProxy ? proxiedFetch : null }, () => next());
+    };
+}

package/dist/socket-client.js

@@ -0,0 +1,317 @@
+const DEFAULT_SERVER_URL = process.env.CONSENSUS_SERVER_URL || "https://consensus.canister.software";
+class SocketClientError extends Error {
+    status;
+    data;
+}
+function trimTrailingSlash(value) {
+    return String(value || "").replace(/\/+$/, "");
+}
+function parseMaybeJson(text) {
+    if (!text)
+        return null;
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return text;
+    }
+}
+function normalizeTokenParams(defaults, params) {
+    const merged = {
+        model: params?.model ?? defaults?.model ?? "hybrid",
+        minutes: params?.minutes ?? defaults?.minutes ?? 5,
+        megabytes: params?.megabytes ?? defaults?.megabytes ?? 50,
+        nodeRegion: params?.nodeRegion ?? defaults?.nodeRegion,
+        nodeDomain: params?.nodeDomain ?? defaults?.nodeDomain,
+        nodeExclude: params?.nodeExclude ?? defaults?.nodeExclude,
+    };
+    if (!["hybrid", "time", "data"].includes(merged.model)) {
+        throw new SocketClientError(`Invalid model '${String(merged.model)}'`);
+    }
+    if (!Number.isInteger(merged.minutes) || merged.minutes < 0) {
+        throw new SocketClientError("minutes must be a non-negative integer");
+    }
+    if (!Number.isInteger(merged.megabytes) || merged.megabytes < 0) {
+        throw new SocketClientError("megabytes must be a non-negative integer");
+    }
+    return merged;
+}
+function toTokenHeaders(params) {
+    const headers = {};
+    if (params?.nodeRegion)
+        headers["x-node-region"] = params.nodeRegion;
+    if (params?.nodeDomain)
+        headers["x-node-domain"] = params.nodeDomain;
+    if (params?.nodeExclude)
+        headers["x-node-exclude"] = params.nodeExclude;
+    return headers;
+}
+async function resolveWebSocketFactory(factory) {
+    if (factory)
+        return factory;
+    if (typeof WebSocket !== "undefined")
+        return WebSocket;
+    const wsModule = await import("ws");
+    const maybeCtor = wsModule.default ||
+        wsModule.WebSocket;
+    if (typeof maybeCtor !== "function") {
+        throw new SocketClientError("Unable to resolve a WebSocket constructor");
+    }
+    return maybeCtor;
+}
+function addListener(socket, event, handler) {
+    if (typeof socket.addEventListener === "function") {
+        socket.addEventListener(event, handler);
+        return;
+    }
+    if (typeof socket.on === "function") {
+        socket.on(event, handler);
+    }
+}
+function removeListener(socket, event, handler) {
+    if (typeof socket.removeEventListener === "function") {
+        socket.removeEventListener(event, handler);
+        return;
+    }
+    if (typeof socket.off === "function") {
+        socket.off(event, handler);
+        return;
+    }
+    if (typeof socket.removeListener === "function") {
+        socket.removeListener(event, handler);
+    }
+}
+function getOpenStateValue(socket) {
+    const maybeCtor = socket;
+    const open = maybeCtor.constructor?.OPEN;
+    return typeof open === "number" ? open : 1;
+}
+function getMessagePayload(value) {
+    if (value && typeof value === "object" && "data" in value) {
+        return value.data;
+    }
+    return value;
+}
+function toSafeResult(promise) {
+    return promise
+        .then((data) => ({ ok: true, data }))
+        .catch((error) => ({ ok: false, error }));
+}
+export function SocketClient(fetchWithPayment, options = {}) {
+    if (typeof fetchWithPayment !== "function") {
+        throw new TypeError("SocketClient requires fetchWithPayment as the first argument");
+    }
+    const baseUrl = trimTrailingSlash(DEFAULT_SERVER_URL);
+    const openTimeoutMs = options.openTimeoutMs ?? 12_000;
+    const reconnectIntervalMs = options.reconnectIntervalMs ?? 2_000;
+    let lastTokenParams;
+    async function requestTokenInternal(params) {
+        const normalized = normalizeTokenParams(options.defaults, params);
+        lastTokenParams = normalized;
+        const query = new URLSearchParams({
+            model: normalized.model,
+            minutes: String(normalized.minutes),
+            megabytes: String(normalized.megabytes),
+        });
+        const response = await fetchWithPayment(`${baseUrl}/ws?${query.toString()}`, {
+            method: "GET",
+            headers: toTokenHeaders(normalized),
+        });
+        const raw = await response.text();
+        const parsed = parseMaybeJson(raw);
+        if (!response.ok) {
+            const message = parsed?.message ||
+                parsed?.error ||
+                `WebSocket token request failed (${response.status})`;
+            const error = new SocketClientError(message);
+            error.status = response.status;
+            error.data = parsed;
+            throw error;
+        }
+        const auth = parsed;
+        if (!auth?.connect_url || !auth?.token) {
+            throw new SocketClientError("Invalid token response: missing token/connect_url");
+        }
+        return {
+            token: String(auth.token),
+            connect_url: String(auth.connect_url),
+            expires_in: Number(auth.expires_in ?? 0),
+        };
+    }
+    async function requestToken(params, safeOptions) {
+        const task = requestTokenInternal(params);
+        if (safeOptions?.safe)
+            return toSafeResult(task);
+        return task;
+    }
+    async function connectInternal(connectUrlOrAuth, callbacks) {
+        const initialConnectUrl = typeof connectUrlOrAuth === "string"
+            ? connectUrlOrAuth
+            : connectUrlOrAuth?.connect_url;
+        if (!initialConnectUrl) {
+            throw new SocketClientError("connect requires connect_url");
+        }
+        const listeners = {
+            open: new Set(),
+            message: new Set(),
+            close: new Set(),
+            error: new Set(),
+        };
+        const state = {
+            connected: false,
+            reconnecting: false,
+            closedByCaller: false,
+        };
+        let currentConnectUrl = initialConnectUrl;
+        let reconnectTimer = null;
+        let activeSocket = null;
+        const socketFactory = await resolveWebSocketFactory(options.webSocketFactory);
+        const connectHeaders = toTokenHeaders(lastTokenParams ?? options.defaults);
+        const emit = (event, ...args) => {
+            for (const handler of listeners[event]) {
+                handler(...args);
+            }
+        };
+        const clearReconnectTimer = () => {
+            if (!reconnectTimer)
+                return;
+            clearTimeout(reconnectTimer);
+            reconnectTimer = null;
+        };
+        const waitForOpen = (socket) => new Promise((resolve, reject) => {
+            let timeout = null;
+            const cleanup = () => {
+                if (timeout)
+                    clearTimeout(timeout);
+                removeListener(socket, "open", onOpen);
+                removeListener(socket, "error", onError);
+                removeListener(socket, "close", onClose);
+            };
+            const onOpen = () => {
+                cleanup();
+                resolve();
+            };
+            const onError = (error) => {
+                cleanup();
+                reject(error);
+            };
+            const onClose = () => {
+                cleanup();
+                reject(new SocketClientError("Socket closed before opening"));
+            };
+            addListener(socket, "open", onOpen);
+            addListener(socket, "error", onError);
+            addListener(socket, "close", onClose);
+            timeout = setTimeout(() => {
+                cleanup();
+                reject(new SocketClientError("Socket open timeout"));
+            }, openTimeoutMs);
+        });
+        const openSocket = async () => {
+            let socketInstance;
+            try {
+                socketInstance = new socketFactory(currentConnectUrl, { headers: connectHeaders });
+            }
+            catch {
+                socketInstance = new socketFactory(currentConnectUrl);
+            }
+            addListener(socketInstance, "open", () => {
+                state.connected = true;
+                state.reconnecting = false;
+                callbacks?.onOpen?.();
+                emit("open");
+            });
+            addListener(socketInstance, "message", (event) => {
+                const payload = getMessagePayload(event);
+                callbacks?.onMessage?.(payload);
+                emit("message", payload);
+            });
+            addListener(socketInstance, "error", (error) => {
+                callbacks?.onError?.(error);
+                emit("error", error);
+            });
+            addListener(socketInstance, "close", (event) => {
+                state.connected = false;
+                callbacks?.onClose?.(event);
+                emit("close", event);
+                if (state.closedByCaller)
+                    return;
+                clearReconnectTimer();
+                reconnectTimer = setTimeout(async () => {
+                    if (state.closedByCaller)
+                        return;
+                    state.reconnecting = true;
+                    try {
+                        if (lastTokenParams) {
+                            const auth = await requestTokenInternal(lastTokenParams);
+                            currentConnectUrl = auth.connect_url;
+                        }
+                        await openSocket();
+                    }
+                    catch (error) {
+                        callbacks?.onError?.(error);
+                        emit("error", error);
+                        if (!state.closedByCaller) {
+                            reconnectTimer = setTimeout(async () => {
+                                if (!state.closedByCaller) {
+                                    state.reconnecting = true;
+                                    try {
+                                        if (lastTokenParams) {
+                                            const auth = await requestTokenInternal(lastTokenParams);
+                                            currentConnectUrl = auth.connect_url;
+                                        }
+                                        await openSocket();
+                                    }
+                                    catch (retryError) {
+                                        callbacks?.onError?.(retryError);
+                                        emit("error", retryError);
+                                    }
+                                }
+                            }, reconnectIntervalMs);
+                        }
+                    }
+                }, reconnectIntervalMs);
+            });
+            activeSocket = socketInstance;
+            await waitForOpen(socketInstance);
+        };
+        await openSocket();
+        return {
+            send(data) {
+                if (!activeSocket) {
+                    throw new SocketClientError("No active socket session");
+                }
+                const openState = getOpenStateValue(activeSocket);
+                if (activeSocket.readyState !== openState) {
+                    throw new SocketClientError("Socket is not open");
+                }
+                activeSocket.send(data);
+            },
+            close(code, reason) {
+                state.closedByCaller = true;
+                state.reconnecting = false;
+                clearReconnectTimer();
+                activeSocket?.close(code, reason);
+            },
+            on(event, handler) {
+                listeners[event].add(handler);
+            },
+            off(event, handler) {
+                listeners[event].delete(handler);
+            },
+            getState() {
+                return { ...state };
+            },
+        };
+    }
+    async function connect(connectUrlOrAuth, callbacks, safeOptions) {
+        const task = connectInternal(connectUrlOrAuth, callbacks);
+        if (safeOptions?.safe)
+            return toSafeResult(task);
+        return task;
+    }
+    return {
+        requestToken,
+        connect,
+    };
+}