claude-ide-bridge 1.1.0

package/dist/extensionClient.js

@@ -0,0 +1,698 @@
+import { WebSocket } from "ws";
+import { BRIDGE_PROTOCOL_VERSION } from "./version.js";
+import { safeSend, waitForDrain } from "./wsUtils.js";
+/** Thrown when an extension request times out — distinguishable from "no results" (null). */
+export class ExtensionTimeoutError extends Error {
+    method;
+    constructor(method) {
+        super(`Extension request ${method} timed out`);
+        this.name = "ExtensionTimeoutError";
+        this.method = method;
+    }
+}
+const REQUEST_TIMEOUT = 10_000;
+export class ExtensionClient {
+    logger;
+    ws = null;
+    connected = false;
+    pendingRequests = new Map();
+    nextId = 0;
+    // Exponential backoff — prevents cascading 10s timeouts when extension is unresponsive
+    extensionSuspendedUntil = 0;
+    extensionFailures = 0;
+    extensionHalfOpen = false;
+    // State pushed by extension via notifications
+    latestDiagnostics = new Map();
+    latestSelection = null;
+    latestActiveFile = null;
+    lastDiagnosticsUpdate = 0;
+    // AI comment cache (pushed by extension)
+    latestAIComments = new Map();
+    // Debug state (pushed by extension via notifications)
+    latestDebugState = null;
+    // Callbacks for forwarding notifications to Claude Code
+    onDiagnosticsChanged = null;
+    onAICommentsChanged = null;
+    onFileChanged = null;
+    onExtensionDisconnected = null;
+    onDebugSessionChanged = null;
+    // Listener set for diagnostics (used by watchDiagnostics long-poll)
+    diagnosticsListeners = new Set();
+    constructor(logger) {
+        this.logger = logger;
+    }
+    /** Invoke a callback safely — log and swallow errors to prevent bridge crash */
+    safeCallback(fn, ...args) {
+        if (!fn)
+            return;
+        try {
+            fn(...args);
+        }
+        catch (err) {
+            this.logger.error(`Callback error: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+    handleExtensionConnection(ws) {
+        // Replace existing connection
+        if (this.ws) {
+            this.logger.info("Replacing existing extension connection");
+            this.rejectAllPending("Extension reconnected");
+            this.ws.removeAllListeners();
+            if (this.ws.readyState === WebSocket.OPEN) {
+                this.ws.terminate();
+            }
+        }
+        this.ws = ws;
+        this.connected = true;
+        // Don't clear cached diagnostics/selection/file state — extension pushes
+        // fresh data on connect, so stale values are harmless for a few seconds.
+        // Reset backoff — fresh connection deserves a clean slate
+        this.extensionSuspendedUntil = 0;
+        this.extensionFailures = 0;
+        this.extensionHalfOpen = false;
+        this.logger.info("Extension client connected");
+        ws.on("message", (data) => {
+            try {
+                const msg = JSON.parse(data.toString("utf-8"));
+                // Response to our request
+                if (msg.id !== undefined && msg.id !== null && !msg.method) {
+                    const pending = this.pendingRequests.get(msg.id);
+                    if (pending) {
+                        this.pendingRequests.delete(msg.id);
+                        clearTimeout(pending.timer);
+                        if (msg.error) {
+                            pending.reject(new Error(msg.error.message));
+                        }
+                        else {
+                            pending.resolve(msg.result);
+                        }
+                    }
+                    else {
+                        this.logger.debug(`Orphaned extension response for id=${msg.id} (likely timed out)`);
+                    }
+                    return;
+                }
+                // Push notification from extension
+                if (msg.method) {
+                    this.handleNotification(msg.method, msg.params);
+                }
+            }
+            catch (err) {
+                this.logger.error(`Extension message parse error: ${err}`);
+            }
+        });
+        // Guard against double close/error cleanup
+        let disconnected = false;
+        const handleDisconnect = (reason) => {
+            if (disconnected)
+                return;
+            disconnected = true;
+            this.connected = false;
+            this.ws = null;
+            this.rejectAllPending(reason);
+            // Clear diagnostics listeners — stale watchDiagnostics closures must not
+            // accumulate across reconnects (they hold references to old AbortSignals).
+            this.diagnosticsListeners.clear();
+            this.logger.info(`Extension disconnected: ${reason}`);
+            this.safeCallback(this.onExtensionDisconnected);
+        };
+        ws.on("close", () => handleDisconnect("Connection closed"));
+        ws.on("error", (err) => {
+            this.logger.error(`Extension WS error: ${err.message}`);
+            // Set disconnected flag before terminate() so any synchronous close event
+            // emitted by terminate() sees the guard as already set.
+            handleDisconnect(`Error: ${err.message}`);
+            ws.terminate();
+        });
+    }
+    handleNotification(method, params) {
+        if (typeof params !== "object" || params === null) {
+            this.logger.debug(`Ignoring notification ${method} with invalid params`);
+            return;
+        }
+        const p = params;
+        switch (method) {
+            case "extension/diagnosticsChanged": {
+                const file = p.file;
+                const diagnostics = p.diagnostics;
+                if (typeof file !== "string" || !Array.isArray(diagnostics)) {
+                    this.logger.debug("Ignoring malformed diagnosticsChanged notification");
+                    return;
+                }
+                if (diagnostics.length === 0) {
+                    this.latestDiagnostics.delete(file);
+                }
+                else {
+                    this.latestDiagnostics.set(file, diagnostics);
+                    // Cap diagnostics cache at 500 entries
+                    if (this.latestDiagnostics.size > 500) {
+                        const firstKey = this.latestDiagnostics.keys().next().value;
+                        if (firstKey !== undefined)
+                            this.latestDiagnostics.delete(firstKey);
+                    }
+                }
+                // Update timestamp and forward to Claude Code
+                this.lastDiagnosticsUpdate = Date.now();
+                this.safeCallback(this.onDiagnosticsChanged, file, diagnostics);
+                for (const fn of [...this.diagnosticsListeners])
+                    this.safeCallback(fn, file, diagnostics);
+                break;
+            }
+            case "extension/selectionChanged": {
+                if (typeof p.file !== "string" ||
+                    typeof p.startLine !== "number" ||
+                    typeof p.endLine !== "number" ||
+                    typeof p.startColumn !== "number" ||
+                    typeof p.endColumn !== "number" ||
+                    typeof p.selectedText !== "string") {
+                    this.logger.debug("Ignoring malformed selectionChanged notification");
+                    return;
+                }
+                this.latestSelection = {
+                    file: p.file,
+                    startLine: p.startLine,
+                    endLine: p.endLine,
+                    startColumn: p.startColumn,
+                    endColumn: p.endColumn,
+                    selectedText: p.selectedText,
+                };
+                break;
+            }
+            case "extension/activeFileChanged": {
+                if (typeof p.file !== "string") {
+                    this.logger.debug("Ignoring malformed activeFileChanged notification");
+                    return;
+                }
+                this.latestActiveFile = p.file;
+                break;
+            }
+            case "extension/aiCommentsChanged": {
+                const comments = p.comments;
+                if (!Array.isArray(comments)) {
+                    this.logger.debug("Ignoring malformed aiCommentsChanged notification");
+                    return;
+                }
+                this.latestAIComments.clear();
+                for (const c of comments) {
+                    const entry = c;
+                    if (typeof entry.file !== "string")
+                        continue;
+                    const existing = this.latestAIComments.get(entry.file) || [];
+                    existing.push(entry);
+                    this.latestAIComments.set(entry.file, existing);
+                }
+                // Cap at 200 files
+                if (this.latestAIComments.size > 200) {
+                    const firstKey = this.latestAIComments.keys().next().value;
+                    if (firstKey !== undefined)
+                        this.latestAIComments.delete(firstKey);
+                }
+                this.safeCallback(this.onAICommentsChanged, comments);
+                break;
+            }
+            case "extension/fileChanged": {
+                const id = p.id;
+                const type = p.type;
+                const file = p.file;
+                if (typeof id === "string" &&
+                    typeof type === "string" &&
+                    typeof file === "string") {
+                    this.safeCallback(this.onFileChanged, id, type, file);
+                }
+                break;
+            }
+            case "extension/hello": {
+                const extVer = typeof p.extensionVersion === "string"
+                    ? p.extensionVersion
+                    : "unknown";
+                this.logger.info(`Extension hello: version=${extVer}`);
+                const [extMajor] = extVer.split(".").map(Number);
+                const [bridgeMajor] = BRIDGE_PROTOCOL_VERSION.split(".").map(Number);
+                if (extMajor !== bridgeMajor) {
+                    this.logger.warn(`Extension major version mismatch: bridge=${BRIDGE_PROTOCOL_VERSION}, extension=${extVer}. Consider updating.`);
+                }
+                break;
+            }
+            case "extension/fileSaved":
+                break;
+            case "extension/debugSessionChanged": {
+                if (typeof p.hasActiveSession !== "boolean") {
+                    this.logger.debug("Ignoring malformed debugSessionChanged notification");
+                    return;
+                }
+                const state = p;
+                this.latestDebugState = state;
+                this.safeCallback(this.onDebugSessionChanged, state);
+                break;
+            }
+            default:
+                this.logger.debug(`Unknown extension notification: ${method}`);
+        }
+    }
+    static MAX_PENDING_REQUESTS = 100;
+    async request(method, params, timeoutMs, signal) {
+        if (this.pendingRequests.size >= ExtensionClient.MAX_PENDING_REQUESTS) {
+            throw new Error(`Too many pending extension requests (${ExtensionClient.MAX_PENDING_REQUESTS})`);
+        }
+        // Exponential backoff — fast-fail if extension is repeatedly timing out
+        const now = Date.now();
+        if (now < this.extensionSuspendedUntil) {
+            throw new ExtensionTimeoutError(method);
+        }
+        // Half-open: backoff expired but failures recorded — allow one probe through
+        if (this.extensionFailures > 0 && !this.extensionHalfOpen) {
+            this.extensionHalfOpen = true;
+            this.logger.debug(`Extension circuit breaker half-open — probing with ${method}`);
+        }
+        if (!this.connected || !this.ws || this.ws.readyState !== WebSocket.OPEN) {
+            throw new Error("Extension not connected");
+        }
+        if (signal?.aborted) {
+            throw new Error("Request aborted");
+        }
+        // Wait for backpressure to clear before sending
+        await waitForDrain(this.ws, this.logger, "Extension backpressure");
+        // Re-check after drain wait — socket may have closed
+        if (!this.connected || !this.ws || this.ws.readyState !== WebSocket.OPEN) {
+            throw new Error("Extension disconnected during drain wait");
+        }
+        const timeout = timeoutMs ?? REQUEST_TIMEOUT;
+        const id = this.nextId++;
+        if (this.nextId >= Number.MAX_SAFE_INTEGER)
+            this.nextId = 0;
+        const inner = new Promise((resolve, reject) => {
+            let settled = false;
+            const settle = (fn) => {
+                if (settled)
+                    return;
+                settled = true;
+                fn();
+            };
+            const timer = setTimeout(() => {
+                this.pendingRequests.delete(id);
+                signal?.removeEventListener("abort", onAbort);
+                this.logger.warn(`Extension request ${method} timed out after ${timeout}ms`);
+                settle(() => reject(new ExtensionTimeoutError(method)));
+            }, timeout);
+            // Re-check abort after the async drain wait — signal may have fired during that gap.
+            // If already aborted, addEventListener would never fire so we must check here.
+            if (signal?.aborted) {
+                clearTimeout(timer);
+                settle(() => reject(new Error("Request aborted")));
+                return;
+            }
+            // Wire AbortSignal to cancel the pending request
+            const onAbort = () => {
+                this.pendingRequests.delete(id);
+                clearTimeout(timer);
+                settle(() => reject(new Error("Request aborted")));
+            };
+            if (signal) {
+                signal.addEventListener("abort", onAbort, { once: true });
+            }
+            this.pendingRequests.set(id, {
+                resolve: (value) => {
+                    signal?.removeEventListener("abort", onAbort);
+                    settle(() => resolve(value));
+                },
+                reject: (reason) => {
+                    signal?.removeEventListener("abort", onAbort);
+                    settle(() => reject(reason));
+                },
+                timer,
+            });
+            const data = JSON.stringify({ jsonrpc: "2.0", id, method, params });
+            if (this.ws && this.ws.readyState === WebSocket.OPEN) {
+                try {
+                    this.ws.send(data);
+                }
+                catch (err) {
+                    this.pendingRequests.delete(id);
+                    clearTimeout(timer);
+                    signal?.removeEventListener("abort", onAbort);
+                    settle(() => reject(new Error(`Failed to send extension request: ${err}`)));
+                }
+            }
+            else {
+                this.pendingRequests.delete(id);
+                clearTimeout(timer);
+                signal?.removeEventListener("abort", onAbort);
+                settle(() => reject(new Error("Extension disconnected before send")));
+            }
+        });
+        try {
+            const result = await inner;
+            // Success — reset backoff and half-open state
+            if (this.extensionFailures > 0) {
+                this.logger.warn("Extension backoff reset — connection recovered");
+            }
+            this.extensionFailures = 0;
+            this.extensionSuspendedUntil = 0;
+            this.extensionHalfOpen = false;
+            return result;
+        }
+        catch (err) {
+            if (err instanceof ExtensionTimeoutError) {
+                this.extensionHalfOpen = false;
+                const failures = ++this.extensionFailures;
+                // Full jitter (AWS-recommended): random in [1, cap] — prevents rhythmic
+                // retry storms when bridge and extension restart simultaneously.
+                const capMs = Math.min(1_000 * 2 ** (failures - 1), 60_000);
+                const backoffMs = Math.floor(Math.random() * capMs) + 1;
+                this.extensionSuspendedUntil = Date.now() + backoffMs;
+                this.logger.warn(`Extension timed out (failure #${failures}) — suspending for ${Math.round(backoffMs / 100) / 10}s`);
+            }
+            throw err;
+        }
+    }
+    /** Like request() but returns null on disconnect instead of rejecting.
+     *  ExtensionTimeoutError is NOT caught — callers must handle it to distinguish
+     *  timeout from genuine "no results" (null). */
+    async requestOrNull(method, params, timeoutMs, signal) {
+        return this.request(method, params, timeoutMs, signal).catch((err) => {
+            if (err instanceof ExtensionTimeoutError)
+                throw err;
+            return null;
+        });
+    }
+    rejectAllPending(reason) {
+        for (const [_id, pending] of this.pendingRequests) {
+            clearTimeout(pending.timer);
+            pending.reject(new Error(reason));
+        }
+        this.pendingRequests.clear();
+    }
+    /** Typed shorthand for requestOrNull — returns T | null without an intermediate variable */
+    async proxy(method, params, timeout, signal) {
+        return this.requestOrNull(method, params, timeout, signal);
+    }
+    async getDiagnostics(file) {
+        return this.proxy("extension/getDiagnostics", { file });
+    }
+    async getSelection() {
+        return this.proxy("extension/getSelection");
+    }
+    async getOpenFiles() {
+        return this.proxy("extension/getOpenFiles");
+    }
+    async isDirty(file) {
+        return this.proxy("extension/isDirty", { file });
+    }
+    async getFileContent(file) {
+        return this.requestOrNull("extension/getFileContent", { file });
+    }
+    async openFile(file, line) {
+        const result = await this.requestOrNull("extension/openFile", {
+            file,
+            line,
+        });
+        return result === true;
+    }
+    async saveFile(file) {
+        const result = await this.requestOrNull("extension/saveFile", { file });
+        return result === true;
+    }
+    async closeTab(file) {
+        const result = await this.requestOrNull("extension/closeTab", { file });
+        return result === true;
+    }
+    async getAIComments() {
+        return this.proxy("extension/getAIComments");
+    }
+    // --- LSP Semantic Features ---
+    async goToDefinition(file, line, column, signal) {
+        return this.requestOrNull("extension/goToDefinition", { file, line, column }, undefined, signal);
+    }
+    async findReferences(file, line, column, signal) {
+        return this.requestOrNull("extension/findReferences", { file, line, column }, undefined, signal);
+    }
+    async getHover(file, line, column, signal) {
+        return this.requestOrNull("extension/getHover", { file, line, column }, undefined, signal);
+    }
+    async getCodeActions(file, startLine, startColumn, endLine, endColumn) {
+        return this.requestOrNull("extension/getCodeActions", {
+            file,
+            startLine,
+            startColumn,
+            endLine,
+            endColumn,
+        });
+    }
+    async applyCodeAction(file, startLine, startColumn, endLine, endColumn, actionTitle) {
+        return this.requestOrNull("extension/applyCodeAction", {
+            file,
+            startLine,
+            startColumn,
+            endLine,
+            endColumn,
+            actionTitle,
+        });
+    }
+    async renameSymbol(file, line, column, newName) {
+        // Rename can be slow on large projects
+        return this.requestOrNull("extension/renameSymbol", { file, line, column, newName }, 15_000);
+    }
+    async searchSymbols(query, maxResults) {
+        return this.requestOrNull("extension/searchSymbols", { query, maxResults });
+    }
+    async watchFiles(id, pattern) {
+        return this.requestOrNull("extension/watchFiles", { id, pattern });
+    }
+    async unwatchFiles(id) {
+        return this.requestOrNull("extension/unwatchFiles", { id });
+    }
+    // --- Terminal Features ---
+    async listTerminals() {
+        return this.requestOrNull("extension/listTerminals");
+    }
+    async getTerminalOutput(name, index, lines) {
+        return this.requestOrNull("extension/getTerminalOutput", {
+            name,
+            index,
+            lines,
+        });
+    }
+    async disposeTerminal(name, index) {
+        return this.requestOrNull("extension/disposeTerminal", { name, index });
+    }
+    // --- File Operations ---
+    async createFile(filePath, content, isDirectory, overwrite, openAfterCreate) {
+        return this.requestOrNull("extension/createFile", {
+            filePath,
+            content,
+            isDirectory,
+            overwrite,
+            openAfterCreate,
+        });
+    }
+    async deleteFile(filePath, recursive, useTrash) {
+        return this.requestOrNull("extension/deleteFile", {
+            filePath,
+            recursive,
+            useTrash,
+        });
+    }
+    async renameFile(oldPath, newPath, overwrite) {
+        return this.requestOrNull("extension/renameFile", {
+            oldPath,
+            newPath,
+            overwrite,
+        });
+    }
+    // --- Text Editing ---
+    async editText(filePath, edits, save) {
+        return this.requestOrNull("extension/editText", { filePath, edits, save });
+    }
+    async replaceBlock(filePath, oldContent, newContent, save) {
+        return this.requestOrNull("extension/replaceBlock", {
+            filePath,
+            oldContent,
+            newContent,
+            save,
+        });
+    }
+    async getDocumentSymbols(file) {
+        return this.requestOrNull("extension/getDocumentSymbols", { file });
+    }
+    async getCallHierarchy(file, line, column, direction, maxResults) {
+        return this.requestOrNull("extension/getCallHierarchy", { file, line, column, direction, maxResults }, 15_000);
+    }
+    // --- Code Actions (format, fix, organize) ---
+    async formatDocument(file) {
+        return this.requestOrNull("extension/formatDocument", { file }, 15_000);
+    }
+    async fixAllLintErrors(file) {
+        return this.requestOrNull("extension/fixAllLintErrors", { file }, 15_000);
+    }
+    async organizeImports(file) {
+        return this.requestOrNull("extension/organizeImports", { file }, 15_000);
+    }
+    // --- Terminal Control ---
+    async createTerminal(name, cwd, env, show) {
+        return this.requestOrNull("extension/createTerminal", {
+            name,
+            cwd,
+            env,
+            show,
+        });
+    }
+    async sendTerminalCommand(text, name, index, addNewline) {
+        return this.requestOrNull("extension/sendTerminalCommand", {
+            text,
+            name,
+            index,
+            addNewline,
+        });
+    }
+    async waitForTerminalOutput(pattern, name, index, timeoutMs) {
+        const requestTimeout = (timeoutMs ?? 30_000) + 5_000;
+        return this.requestOrNull("extension/waitForTerminalOutput", { pattern, name, index, timeoutMs }, requestTimeout);
+    }
+    async executeInTerminal(command, name, index, timeoutMs, show) {
+        // Add 5s overhead beyond the command timeout so the bridge doesn't cut the extension off early
+        const requestTimeout = (timeoutMs ?? 30_000) + 5_000;
+        return this.requestOrNull("extension/executeInTerminal", { command, name, index, timeoutMs, show }, requestTimeout);
+    }
+    // --- Debug ---
+    async getDebugState() {
+        return this.proxy("extension/getDebugState");
+    }
+    async evaluateInDebugger(expression, frameId, context) {
+        return this.requestOrNull("extension/evaluateInDebugger", {
+            expression,
+            frameId,
+            context,
+        });
+    }
+    async setDebugBreakpoints(file, breakpoints) {
+        return this.requestOrNull("extension/setDebugBreakpoints", {
+            file,
+            breakpoints,
+        });
+    }
+    async startDebugging(configName) {
+        return this.requestOrNull("extension/startDebugging", { configName }, 15_000);
+    }
+    async stopDebugging() {
+        return this.requestOrNull("extension/stopDebugging");
+    }
+    // --- Decorations ---
+    async setDecorations(id, file, decorations) {
+        return this.requestOrNull("extension/setDecorations", {
+            id,
+            file,
+            decorations,
+        });
+    }
+    async clearDecorations(id) {
+        return this.requestOrNull("extension/clearDecorations", { id });
+    }
+    // --- VS Code Commands ---
+    async executeVSCodeCommand(command, args) {
+        return this.requestOrNull("extension/executeVSCodeCommand", {
+            command,
+            args,
+        });
+    }
+    async listVSCodeCommands(filter) {
+        return this.proxy("extension/listVSCodeCommands", { filter });
+    }
+    // --- Workspace Settings ---
+    async getWorkspaceSettings(section, target) {
+        return this.requestOrNull("extension/getWorkspaceSettings", {
+            section,
+            target,
+        });
+    }
+    async setWorkspaceSetting(key, value, target) {
+        return this.requestOrNull("extension/setWorkspaceSetting", {
+            key,
+            value,
+            target,
+        });
+    }
+    // --- Clipboard ---
+    async readClipboard() {
+        return this.requestOrNull("extension/readClipboard");
+    }
+    async writeClipboard(text) {
+        return this.requestOrNull("extension/writeClipboard", { text });
+    }
+    // --- Inlay Hints ---
+    async getInlayHints(file, startLine, endLine) {
+        return this.requestOrNull("extension/getInlayHints", {
+            file,
+            startLine,
+            endLine,
+        });
+    }
+    // --- Type Hierarchy ---
+    async getTypeHierarchy(file, line, column, direction, maxResults) {
+        return this.requestOrNull("extension/getTypeHierarchy", { file, line, column, direction, maxResults }, 15_000);
+    }
+    // --- Tasks ---
+    async listTasks() {
+        return this.requestOrNull("extension/listTasks", undefined, 15_000);
+    }
+    async runTask(name, type, timeoutMs) {
+        const requestTimeout = (timeoutMs ?? 60_000) + 5_000;
+        return this.requestOrNull("extension/runTask", { name, type, timeoutMs }, requestTimeout);
+    }
+    // --- Workspace Folders ---
+    async getWorkspaceFolders() {
+        return this.proxy("extension/getWorkspaceFolders");
+    }
+    // --- Notebook ---
+    async getNotebookCells(file) {
+        return this.requestOrNull("extension/getNotebookCells", { file });
+    }
+    async runNotebookCell(file, cellIndex, timeoutMs) {
+        const requestTimeout = (timeoutMs ?? 30_000) + 5_000;
+        return this.requestOrNull("extension/runNotebookCell", { file, cellIndex, timeoutMs }, requestTimeout);
+    }
+    async getNotebookOutput(file, cellIndex) {
+        return this.requestOrNull("extension/getNotebookOutput", {
+            file,
+            cellIndex,
+        });
+    }
+    // --- Diagnostics Helpers ---
+    getCachedDiagnostics(file) {
+        if (file)
+            return this.latestDiagnostics.get(file) ?? [];
+        return Array.from(this.latestDiagnostics.values()).flat();
+    }
+    addDiagnosticsListener(listener) {
+        this.diagnosticsListeners.add(listener);
+        return () => this.diagnosticsListeners.delete(listener);
+    }
+    /** Notify the extension about Claude Code connection state changes */
+    notifyClaudeConnectionState(connected) {
+        if (!this.ws || this.ws.readyState !== WebSocket.OPEN)
+            return;
+        void safeSend(this.ws, JSON.stringify({
+            jsonrpc: "2.0",
+            method: "bridge/claudeConnectionChanged",
+            params: { connected },
+        }), this.logger);
+    }
+    getCircuitBreakerState() {
+        return {
+            suspended: Date.now() < this.extensionSuspendedUntil,
+            suspendedUntil: this.extensionSuspendedUntil,
+            failures: this.extensionFailures,
+        };
+    }
+    isConnected() {
+        return this.connected;
+    }
+    disconnect() {
+        if (this.ws) {
+            this.ws.close(1000, "Bridge shutting down");
+            this.ws = null;
+        }
+        this.connected = false;
+        this.rejectAllPending("Bridge shutting down");
+    }
+}
+//# sourceMappingURL=extensionClient.js.map