@termfleet/core 0.1.0

package/dist/provider-client.js

@@ -0,0 +1,666 @@
+import { asError } from "@termfleet/core/lib/errors.js";
+import { io } from "socket.io-client";
+import { directProviderUrlResolver } from "./provider-url-resolver.js";
+const controlSocketTimeoutMs = 10_000;
+export class ProviderClient {
+    ref;
+    authToken;
+    urls;
+    apiBase;
+    socket;
+    // One fan-out per socket dispatches agent-session events to every subscription,
+    // keyed by sessionId — instead of one set of socket listeners per subscription.
+    agentSubscriptions = new Map();
+    agentListenersSocket;
+    constructor(ref, options = {}) {
+        this.ref = ref;
+        this.authToken = options.authToken;
+        this.urls = options.urlResolver ?? directProviderUrlResolver;
+        this.apiBase = this.urls.httpBase(ref.baseUrl);
+    }
+    async health() {
+        const response = await this.fetchProviderUrl(`${this.apiBase}/healthz`);
+        if (!response.ok) {
+            throw new Error(await response.text());
+        }
+        const health = await response.json();
+        if (health.ok !== true || !health.provider) {
+            throw new Error(`${this.ref.baseUrl} did not return a valid provider health response.`);
+        }
+        return health;
+    }
+    async snapshot() {
+        const response = await this.fetchProviderUrl(`${this.apiBase}/api/mirror/snapshot`);
+        if (!response.ok) {
+            throw new Error(await response.text());
+        }
+        return parseProviderSnapshot(await response.json(), this.ref.baseUrl);
+    }
+    async updateProviderSettings(settings) {
+        return await this.patchJson("/api/provider-settings", settings);
+    }
+    async lifecycle() {
+        const response = await this.fetchProviderUrl(`${this.apiBase}/api/lifecycle`);
+        if (!response.ok) {
+            throw new Error(await response.text());
+        }
+        return parseLifecycleSnapshot(await response.json(), this.ref.baseUrl);
+    }
+    // Kill orphan `prefix-*` tmux sessions the provider no longer tracks (issue
+    // #14) — bulk recovery for a worker stuck at "capacity full" after a crash.
+    async pruneOrphanSessions() {
+        return await this.postJson("/api/lifecycle/prune", undefined);
+    }
+    async registryProviders(options = {}) {
+        const response = await this.fetchProviderUrl(`${this.apiBase}/api/registry/providers`, {
+            headers: options.authToken ? { authorization: `Bearer ${options.authToken}` } : undefined
+        });
+        if (!response.ok) {
+            throw new Error(await response.text());
+        }
+        return await response.json();
+    }
+    async registerLocalProvider(provider) {
+        return await this.postJson("/api/registry/local-providers", provider);
+    }
+    async unregisterLocalProvider(baseUrl) {
+        const url = new URL(`${this.apiBase}/api/registry/local-providers`);
+        url.searchParams.set("baseUrl", baseUrl);
+        const response = await this.fetchProviderUrl(url, { method: "DELETE" });
+        if (!response.ok) {
+            throw new Error(await response.text());
+        }
+        return await response.json();
+    }
+    async registerSharedProvider(provider, options) {
+        return await this.postJson("/api/registry/remote-providers", provider, {
+            authorization: `Bearer ${options.authToken}`
+        });
+    }
+    async unregisterSharedProvider(baseUrl, options) {
+        const url = new URL(`${this.apiBase}/api/registry/remote-providers`);
+        url.searchParams.set("baseUrl", baseUrl);
+        const response = await this.fetchProviderUrl(url, {
+            headers: { authorization: `Bearer ${options.authToken}` },
+            method: "DELETE"
+        });
+        if (!response.ok) {
+            throw new Error(await response.text());
+        }
+        return await response.json();
+    }
+    async startDockerWorker(options = {}) {
+        return await this.postJson("/api/docker-worker/start", options);
+    }
+    async startLocalProvider(options) {
+        return await this.postJson("/api/local-provider/start", options);
+    }
+    async signInToRegistry(identifier, password) {
+        return await this.postJson("/api/auth/sign-in", { identifier, password });
+    }
+    async registrySession(authToken) {
+        const response = await this.fetchProviderUrl(`${this.apiBase}/api/auth/session`, {
+            headers: { authorization: `Bearer ${authToken}` }
+        });
+        if (!response.ok) {
+            throw new Error(await response.text());
+        }
+        return await response.json();
+    }
+    async signOutOfRegistry(authToken) {
+        return await this.postJson("/api/auth/sign-out", undefined, {
+            authorization: `Bearer ${authToken}`
+        });
+    }
+    async switchRegistryOrganization(organizationId, options) {
+        return await this.postJson("/api/auth/active-organization", { organizationId }, {
+            authorization: `Bearer ${options.authToken}`
+        });
+    }
+    async captureTerminal(terminalId, lines, options = {}) {
+        const url = new URL(`${this.apiBase}/api/terminals/${encodeURIComponent(terminalId)}/capture`);
+        if (lines !== undefined) {
+            url.searchParams.set("lines", String(lines));
+        }
+        if (options.preserveEscapes) {
+            url.searchParams.set("preserveEscapes", "1");
+        }
+        const response = await this.fetchProviderUrl(url);
+        if (!response.ok) {
+            throw new Error(await response.text());
+        }
+        const result = await response.json();
+        if (typeof result.content !== "string") {
+            throw new Error(`Provider ${this.ref.baseUrl} did not return terminal capture content.`);
+        }
+        return { content: result.content };
+    }
+    async getAgentSession(agent, sessionId, options = {}) {
+        const url = new URL(`${this.apiBase}/api/agents/${agent}/sessions/${encodeURIComponent(sessionId)}`);
+        if (options.cwd) {
+            url.searchParams.set("cwd", options.cwd);
+        }
+        const response = await this.fetchProviderUrl(url);
+        if (!response.ok) {
+            throw new Error(await response.text());
+        }
+        const result = await response.json();
+        if (typeof result.sessionId !== "string" || typeof result.lastAssistantText !== "string") {
+            throw new Error(`Provider ${this.ref.baseUrl} did not return valid agent session details.`);
+        }
+        if (result.provider !== agent) {
+            throw new Error(`Provider ${this.ref.baseUrl} returned ${result.provider} details for ${agent} session request.`);
+        }
+        return result;
+    }
+    async getAgentSubagentSession(sessionId, agentId) {
+        const url = new URL(`${this.apiBase}/api/agents/claude/sessions/${encodeURIComponent(sessionId)}/subagents/${encodeURIComponent(agentId)}`);
+        const response = await this.fetchProviderUrl(url);
+        if (!response.ok) {
+            throw new Error(await response.text());
+        }
+        const result = await response.json();
+        if (typeof result.sessionId !== "string" || typeof result.lastAssistantText !== "string") {
+            throw new Error(`Provider ${this.ref.baseUrl} did not return valid subagent session details.`);
+        }
+        return result;
+    }
+    async listAgentSessions(options = {}) {
+        const url = new URL(`${this.apiBase}/api/agents/sessions`);
+        if (options.cursor) {
+            url.searchParams.set("cursor", options.cursor);
+        }
+        if (options.limit !== undefined) {
+            url.searchParams.set("limit", String(options.limit));
+        }
+        if (options.query) {
+            url.searchParams.set("query", options.query);
+        }
+        const response = await this.fetchProviderUrl(url);
+        if (!response.ok) {
+            throw new Error(await response.text());
+        }
+        const result = await response.json();
+        if (!Array.isArray(result.rows)) {
+            throw new Error(`Provider ${this.ref.baseUrl} did not return a valid agent session index.`);
+        }
+        return result;
+    }
+    connect() {
+        if (this.socket) {
+            if (!this.socket.connected) {
+                this.socket.connect();
+            }
+            return this.socket;
+        }
+        const socketTarget = this.urls.socketTarget(this.ref.baseUrl);
+        this.socket = io(socketTarget.origin, {
+            auth: (callback) => callback({ token: this.readAuthToken() }),
+            autoConnect: true,
+            path: socketTarget.path,
+            query: this.urls.wsAuthQuery(),
+            reconnection: true,
+            reconnectionAttempts: Infinity,
+            reconnectionDelay: 250,
+            reconnectionDelayMax: 5000,
+            timeout: controlSocketTimeoutMs,
+            transports: ["websocket"]
+        });
+        return this.socket;
+    }
+    disconnect() {
+        this.socket?.disconnect();
+        this.socket = undefined;
+        this.agentListenersSocket = undefined;
+    }
+    onSnapshot(handler) {
+        const socket = this.connect();
+        socket.on("provider:snapshot", handler);
+        return () => socket.off("provider:snapshot", handler);
+    }
+    onAgentSession(sessionId, handlers, options = {}) {
+        const socket = this.connect();
+        this.wireAgentSessionListeners(socket);
+        const subscription = {
+            handlers,
+            request: { sessionId, ...(options.cwd ? { cwd: options.cwd } : {}) }
+        };
+        let set = this.agentSubscriptions.get(sessionId);
+        if (!set) {
+            set = new Set();
+            this.agentSubscriptions.set(sessionId, set);
+        }
+        set.add(subscription);
+        if (socket.connected) {
+            this.subscribeAgentSession(socket, subscription.request);
+        }
+        return () => {
+            const current = this.agentSubscriptions.get(sessionId);
+            if (!current)
+                return;
+            current.delete(subscription);
+            if (current.size === 0) {
+                this.agentSubscriptions.delete(sessionId);
+                if (socket.connected)
+                    socket.emit("agent-session:unsubscribe", subscription.request);
+            }
+        };
+    }
+    // Attach the shared agent-session listeners once per socket. A reconnect fires
+    // the single `connect` handler, which re-subscribes each active sessionId once
+    // (not once per open chat), and update/error fan out to all subscriptions.
+    wireAgentSessionListeners(socket) {
+        if (this.agentListenersSocket === socket)
+            return;
+        this.agentListenersSocket = socket;
+        socket.on("connect", () => {
+            for (const set of this.agentSubscriptions.values()) {
+                const first = set.values().next().value;
+                if (first)
+                    this.subscribeAgentSession(socket, first.request);
+            }
+        });
+        socket.on("agent-session:update", (payload) => {
+            const update = parseAgentSessionUpdate(payload);
+            if (!update)
+                return;
+            const set = this.agentSubscriptions.get(update.sessionId);
+            if (set)
+                for (const entry of set)
+                    entry.handlers.update(update.details);
+        });
+        socket.on("agent-session:error", (payload) => {
+            const error = parseAgentSessionError(payload);
+            if (!error)
+                return;
+            const set = this.agentSubscriptions.get(error.sessionId);
+            if (set)
+                for (const entry of set)
+                    entry.handlers.error?.(error.error);
+        });
+    }
+    subscribeAgentSession(socket, request) {
+        socket.timeout(controlSocketTimeoutMs).emit("agent-session:subscribe", request, (timeoutError, ack) => {
+            const set = this.agentSubscriptions.get(request.sessionId);
+            if (!set)
+                return;
+            if (timeoutError) {
+                for (const entry of set)
+                    entry.handlers.error?.(timeoutError.message);
+                return;
+            }
+            if (ack?.ok !== true) {
+                for (const entry of set)
+                    entry.handlers.error?.(ack?.error ?? "Agent session subscription failed.");
+                return;
+            }
+            if (ack.result?.details && ack.result.sessionId === request.sessionId) {
+                for (const entry of set)
+                    entry.handlers.update(ack.result.details);
+            }
+        });
+    }
+    async createWindow(options = {}) {
+        return await this.command("window:create", options);
+    }
+    async createAgentWindow(options, clientOptions = {}) {
+        // Backward/forward compat: the create-body field was renamed sessionId -> agentSessionId
+        // (951862f). A long-running provider may predate or postdate this CLI, so send BOTH names —
+        // otherwise a version skew silently drops the requested --session-id and the agent generates
+        // its own, breaking deterministic session tracking. Providers read whichever they know.
+        const body = options.agentSessionId
+            ? { ...options, sessionId: options.agentSessionId }
+            : options;
+        return await this.command("agent:create", body, { timeoutMs: clientOptions.timeoutMs ?? 30_000 });
+    }
+    async moveWindow(id, bounds) {
+        return await this.command("window:move", {
+            height: bounds.height,
+            id,
+            left: bounds.left,
+            top: bounds.top,
+            width: bounds.width
+        });
+    }
+    async closeWindow(id) {
+        return await this.command("window:close", { id });
+    }
+    // Act on a session by id — the provider resolves window→terminal internally, so
+    // an SDK caller never has to descend to a terminalId to reply to or close a
+    // session (the session-first primary abstraction).
+    async sendToSession(agentSessionId, data, options = {}) {
+        return await this.command("agent-session:input", {
+            agentSessionId,
+            data,
+            ...(options.submitMode ? { submitMode: options.submitMode } : {})
+        });
+    }
+    async closeSession(agentSessionId) {
+        return await this.command("agent-session:close", { agentSessionId });
+    }
+    async resizeDisplay(bounds) {
+        return await this.command("display:resize", {
+            height: bounds.height,
+            width: bounds.width
+        });
+    }
+    async sendTerminalInput(terminalId, data, options = {}) {
+        return await this.command("terminal:input", {
+            data,
+            terminalId,
+            ...(options.breakGlass ? { breakGlass: true } : {}),
+            ...(options.submitMode ? { submitMode: options.submitMode } : {})
+        });
+    }
+    async sendLine(terminalId, line, options = {}) {
+        return await this.sendTerminalInput(terminalId, `${line}\n`, options);
+    }
+    // Apply a transient visual effect (flash/dim/highlight) to a terminal — e.g.
+    // to surface a terminal you lost. Shows on every tmux client of the pane and
+    // in the browser mirror; self-expires after the hold duration.
+    async setTerminalEffect(terminalId, kind, options = {}) {
+        return await this.command("terminal:effect", {
+            kind,
+            terminalId,
+            ...(options.durationMs ? { durationMs: options.durationMs } : {})
+        });
+    }
+    async listDirectory(terminalId, path) {
+        const url = new URL(`${this.apiBase}/api/files/list`);
+        url.searchParams.set("terminalId", terminalId);
+        url.searchParams.set("path", path);
+        const response = await this.fetchProviderUrl(url);
+        if (!response.ok) {
+            throw new Error(await response.text());
+        }
+        return await response.json();
+    }
+    async listDirectoryByFilesystem(filesystemId, path) {
+        const url = new URL(`${this.apiBase}/api/files/list`);
+        url.searchParams.set("filesystemId", filesystemId);
+        url.searchParams.set("path", path);
+        const response = await this.fetchProviderUrl(url);
+        if (!response.ok) {
+            throw new Error(await response.text());
+        }
+        return await response.json();
+    }
+    async readFile(terminalId, path) {
+        const url = new URL(`${this.apiBase}/api/files`);
+        url.searchParams.set("terminalId", terminalId);
+        url.searchParams.set("path", path);
+        const response = await this.fetchProviderUrl(url);
+        if (!response.ok) {
+            throw new Error(await response.text());
+        }
+        return new Uint8Array(await response.arrayBuffer());
+    }
+    async readFileByFilesystem(filesystemId, path) {
+        const url = new URL(`${this.apiBase}/api/files`);
+        url.searchParams.set("filesystemId", filesystemId);
+        url.searchParams.set("path", path);
+        const response = await this.fetchProviderUrl(url);
+        if (!response.ok) {
+            throw new Error(await response.text());
+        }
+        return new Uint8Array(await response.arrayBuffer());
+    }
+    async statFile(terminalId, path) {
+        const url = new URL(`${this.apiBase}/api/files/stat`);
+        url.searchParams.set("terminalId", terminalId);
+        url.searchParams.set("path", path);
+        const response = await this.fetchProviderUrl(url);
+        if (!response.ok) {
+            throw new Error(await response.text());
+        }
+        return await response.json();
+    }
+    async statFileByFilesystem(filesystemId, path) {
+        const url = new URL(`${this.apiBase}/api/files/stat`);
+        url.searchParams.set("filesystemId", filesystemId);
+        url.searchParams.set("path", path);
+        const response = await this.fetchProviderUrl(url);
+        if (!response.ok) {
+            throw new Error(await response.text());
+        }
+        return await response.json();
+    }
+    async writeFile(terminalId, path, data, options = {}) {
+        const url = new URL(`${this.apiBase}/api/files`);
+        url.searchParams.set("terminalId", terminalId);
+        url.searchParams.set("path", path);
+        if (options.mkdirs) {
+            url.searchParams.set("mkdirs", "1");
+        }
+        if (options.mode) {
+            url.searchParams.set("mode", options.mode);
+        }
+        const response = await this.fetchProviderUrl(url, {
+            body: new Uint8Array(data),
+            method: "PUT"
+        });
+        if (!response.ok) {
+            throw new Error(await response.text());
+        }
+        return await response.json();
+    }
+    async writeFileByFilesystem(filesystemId, path, data, options = {}) {
+        const url = new URL(`${this.apiBase}/api/files`);
+        url.searchParams.set("filesystemId", filesystemId);
+        url.searchParams.set("path", path);
+        if (options.mkdirs) {
+            url.searchParams.set("mkdirs", "1");
+        }
+        if (options.mode) {
+            url.searchParams.set("mode", options.mode);
+        }
+        const response = await this.fetchProviderUrl(url, {
+            body: new Uint8Array(data),
+            method: "PUT"
+        });
+        if (!response.ok) {
+            throw new Error(await response.text());
+        }
+        return await response.json();
+    }
+    async postJson(path, body, headers = {}) {
+        return await this.writeJson("POST", path, body, headers);
+    }
+    async patchJson(path, body, headers = {}) {
+        return await this.writeJson("PATCH", path, body, headers);
+    }
+    async writeJson(method, path, body, headers = {}) {
+        const response = await this.fetchProviderUrl(`${this.apiBase}${path}`, {
+            body: body === undefined ? undefined : JSON.stringify(body),
+            headers: {
+                ...headers,
+                ...(body === undefined ? {} : { "content-type": "application/json" })
+            },
+            method
+        });
+        if (!response.ok) {
+            throw new Error(await response.text());
+        }
+        return await response.json();
+    }
+    async command(event, payload, options = {}) {
+        const timeoutMs = options.timeoutMs ?? controlSocketTimeoutMs;
+        const socket = this.connect();
+        await waitForConnected(socket, timeoutMs);
+        const response = await new Promise((resolve, reject) => {
+            socket.timeout(timeoutMs).emit(event, payload, (timeoutError, ack) => {
+                if (timeoutError) {
+                    reject(timeoutError);
+                    return;
+                }
+                if (!ack) {
+                    reject(new Error(`Provider command ${event} did not return an acknowledgement.`));
+                    return;
+                }
+                resolve(ack);
+            });
+        });
+        if (response.ok !== true) {
+            throw new Error(response.error ?? `Provider command ${event} failed.`);
+        }
+        return response;
+    }
+    async fetchProviderUrl(input, init = {}) {
+        return await fetchProviderUrl(input, {
+            ...init,
+            headers: withBearerHeaders(init.headers, this.readAuthToken())
+        });
+    }
+    readAuthToken() {
+        return this.authToken?.();
+    }
+}
+async function fetchProviderUrl(input, init) {
+    const url = input instanceof URL ? input : new URL(input);
+    try {
+        return await fetch(url, init);
+    }
+    catch (error) {
+        throw new Error(`Provider request failed: ${url.href}: ${asError(error).message}`);
+    }
+}
+function withBearerHeaders(headers, token) {
+    if (!token) {
+        return headers;
+    }
+    const next = new Headers(headers);
+    if (!next.has("authorization")) {
+        next.set("authorization", `Bearer ${token}`);
+    }
+    return next;
+}
+function parseProviderSnapshot(value, baseUrl) {
+    const snapshot = value;
+    if (!snapshot || typeof snapshot !== "object") {
+        throw new Error(`${baseUrl} did not return a mirror snapshot object.`);
+    }
+    if (typeof snapshot.epoch !== "string" || snapshot.epoch.length === 0) {
+        throw new Error(`${baseUrl} mirror snapshot is missing epoch.`);
+    }
+    if (typeof snapshot.revision !== "number" || !Number.isInteger(snapshot.revision) || snapshot.revision < 0) {
+        throw new Error(`${baseUrl} mirror snapshot is missing revision.`);
+    }
+    if (typeof snapshot.observedAt !== "string" || snapshot.observedAt.length === 0) {
+        throw new Error(`${baseUrl} mirror snapshot is missing observedAt.`);
+    }
+    if (snapshot.provider !== "iterm" && snapshot.provider !== "virtual-tmux" && snapshot.provider !== "wezterm") {
+        throw new Error(`${baseUrl} mirror snapshot has unsupported provider.`);
+    }
+    if (!snapshot.displayBounds || !Array.isArray(snapshot.windows)) {
+        throw new Error(`${baseUrl} mirror snapshot is missing display bounds or windows.`);
+    }
+    if (!snapshot.lifecycle || !Array.isArray(snapshot.lifecycle.panes) || !Array.isArray(snapshot.lifecycle.sessions)) {
+        throw new Error(`${baseUrl} mirror snapshot is missing lifecycle.`);
+    }
+    return snapshot;
+}
+function parseLifecycleSnapshot(value, baseUrl) {
+    const lifecycle = value;
+    if (!lifecycle || typeof lifecycle !== "object") {
+        throw new Error(`${baseUrl} did not return a lifecycle object.`);
+    }
+    if (typeof lifecycle.observedAt !== "string" || !Array.isArray(lifecycle.panes) || !Array.isArray(lifecycle.sessions)) {
+        throw new Error(`${baseUrl} lifecycle response is missing observedAt, panes, or sessions.`);
+    }
+    return lifecycle;
+}
+function parseAgentSessionUpdate(value) {
+    if (!value || typeof value !== "object") {
+        return undefined;
+    }
+    const payload = value;
+    if (typeof payload.sessionId !== "string" || !payload.details || typeof payload.details !== "object") {
+        return undefined;
+    }
+    return {
+        details: payload.details,
+        sessionId: payload.sessionId
+    };
+}
+function parseAgentSessionError(value) {
+    if (!value || typeof value !== "object") {
+        return undefined;
+    }
+    const payload = value;
+    if (typeof payload.sessionId !== "string" || typeof payload.error !== "string") {
+        return undefined;
+    }
+    return {
+        error: payload.error,
+        sessionId: payload.sessionId
+    };
+}
+export function providerRefFromUrl(value, label = "Provider") {
+    const url = new URL(value);
+    return {
+        baseUrl: url.origin,
+        id: `provider-${machineIdSlug(url.origin)}`,
+        label
+    };
+}
+// The single place a machine's durable board/layout id is resolved. Identity is
+// the provider-minted instanceId once the console has learned it; a machine the
+// console has never reached falls back to the legacy address-derived id, and
+// only until its first probe stamps an instanceId. One named resolver — never a
+// scattered `record.instanceId ?? …` at use sites (the no-fallback convention).
+export function resolveMachineId(record) {
+    return record.instanceId
+        ? `provider-${machineIdSlug(record.instanceId)}`
+        : providerRefFromUrl(record.baseUrl).id;
+}
+// The `provider-` prefix that turns an already-resolved machine id into its
+// console-layout / board-node key. The one place the prefixing lives: the
+// frontend board read seam (`readMachinePlacement`) holds a resolved
+// `provider.id` and derives the key here, while server-side reconciliation goes
+// through `machineLayoutKey` below — both land on the identical key.
+export function machineLayoutKeyForId(machineId) {
+    return `provider-${machineId}`;
+}
+// The console-layout / board-node key for a machine record. The board builds its
+// node id as `provider-${provider.id}` (graph-model) where `provider.id` is
+// resolveMachineId(record); the layout is keyed by that node id. Server-side
+// reconciliation must target the SAME key, so it derives it here rather than
+// re-deriving the `provider-` prefixing by hand.
+export function machineLayoutKey(record) {
+    return machineLayoutKeyForId(resolveMachineId(record));
+}
+function machineIdSlug(value) {
+    return value.replace(/[^a-z0-9]/gi, "-").replace(/-+/g, "-").replace(/^-+|-+$/g, "").toLowerCase();
+}
+function waitForConnected(socket, timeoutMs) {
+    if (socket.connected) {
+        return Promise.resolve();
+    }
+    return new Promise((resolve, reject) => {
+        // The manager retries forever (reconnection: Infinity), so connect_error
+        // and disconnect are transient per-attempt failures, not verdicts. Failing
+        // the command on the first unlucky attempt forfeits the rest of its
+        // timeout budget; instead keep waiting and report the last error if the
+        // deadline expires.
+        let lastError;
+        const timer = setTimeout(() => {
+            cleanup();
+            const detail = lastError ? ` Last error: ${lastError.message}` : "";
+            reject(new Error(`Timed out waiting for provider control socket to connect.${detail}`));
+        }, timeoutMs);
+        const onConnect = () => {
+            cleanup();
+            resolve();
+        };
+        const onConnectError = (error) => {
+            lastError = error;
+        };
+        const cleanup = () => {
+            clearTimeout(timer);
+            socket.off("connect", onConnect);
+            socket.off("connect_error", onConnectError);
+        };
+        socket.on("connect", onConnect);
+        socket.on("connect_error", onConnectError);
+    });
+}

package/dist/provider-url-resolver.d.ts

@@ -0,0 +1,16 @@
+export type ProviderUrlResolver = {
+    httpBase(providerBaseUrl: string): string;
+    socketTarget(providerBaseUrl: string): {
+        origin: string;
+        path: string;
+    };
+    wsBase(providerBaseUrl: string): string;
+    wsAuthQuery(): Record<string, string>;
+};
+export declare const providerProxyPathPrefix = "/providers/";
+export declare function providerProxyKey(providerBaseUrl: string): string;
+export declare function providerProxyPath(providerBaseUrl: string): string;
+export declare const directProviderUrlResolver: ProviderUrlResolver;
+export declare function consoleProxyProviderUrlResolver(consoleOrigin: string, options?: {
+    sessionToken?: () => string | undefined;
+}): ProviderUrlResolver;