@rahul_ur/devlink-bridge 1.0.0

package/dist/types.d.ts

@@ -0,0 +1,87 @@
+export type BrowserMessage = {
+    type: 'handshake';
+    protocolVersion: string;
+    clientId: string;
+} | {
+    type: 'readFile';
+    id: string;
+    path: string;
+} | {
+    type: 'writeFile';
+    id: string;
+    path: string;
+    content: string;
+    writeId: string;
+} | {
+    type: 'readDir';
+    id: string;
+    path: string;
+    recursive?: boolean;
+} | {
+    type: 'watchFile';
+    id: string;
+    path: string;
+} | {
+    type: 'unwatchFile';
+    id: string;
+    path: string;
+} | {
+    type: 'ping';
+    id: string;
+};
+export type ExtensionMessage = {
+    type: 'handshakeAck';
+    protocolVersion: string;
+    workspaceRoot: string;
+} | {
+    type: 'response';
+    id: string;
+    ok: true;
+    result: unknown;
+} | {
+    type: 'response';
+    id: string;
+    ok: false;
+    error: string;
+} | {
+    type: 'fileChanged';
+    path: string;
+    content: string;
+    writeId?: string;
+} | {
+    type: 'fileDeleted';
+    path: string;
+} | {
+    type: 'pong';
+    id: string;
+};
+export interface CacheEntry {
+    content: string;
+    version: number;
+    lastFetched: number;
+    watchActive: boolean;
+}
+export interface BridgeOptions {
+    /** Port range to try. Defaults to 7100–7200 */
+    portRange?: [number, number];
+    /** Specific port to try first */
+    port?: number;
+    /** Heartbeat interval in ms. Defaults to 5000 */
+    heartbeatMs?: number;
+    /** Request timeout in ms. Defaults to 10000 */
+    timeoutMs?: number;
+    /** Max reconnect attempts before giving up. Defaults to Infinity */
+    maxReconnectAttempts?: number;
+    /** Base delay for reconnect backoff in ms. Defaults to 500 */
+    reconnectBaseMs?: number;
+    /** Called when connection state changes */
+    onStatusChange?: (status: BridgeStatus) => void;
+}
+export type BridgeStatus = 'connecting' | 'connected' | 'reconnecting' | 'disconnected';
+export interface DirEntry {
+    name: string;
+    path: string;
+    type: 'file' | 'directory';
+    children?: DirEntry[];
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAEA,MAAM,MAAM,cAAc,GACtB;IAAE,IAAI,EAAE,WAAW,CAAC;IAAC,eAAe,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,GAChE;IAAE,IAAI,EAAE,UAAU,CAAC;IAAC,EAAE,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GAC9C;IAAE,IAAI,EAAE,WAAW,CAAC;IAAC,EAAE,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,GACjF;IAAE,IAAI,EAAE,SAAS,CAAC;IAAC,EAAE,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,SAAS,CAAC,EAAE,OAAO,CAAA;CAAE,GAClE;IAAE,IAAI,EAAE,WAAW,CAAC;IAAC,EAAE,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GAC/C;IAAE,IAAI,EAAE,aAAa,CAAC;IAAC,EAAE,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GACjD;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,MAAM,CAAA;CAAE,CAAC;AAIjC,MAAM,MAAM,gBAAgB,GACxB;IAAE,IAAI,EAAE,cAAc,CAAC;IAAC,eAAe,EAAE,MAAM,CAAC;IAAC,aAAa,EAAE,MAAM,CAAA;CAAE,GACxE;IAAE,IAAI,EAAE,UAAU,CAAC;IAAC,EAAE,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,IAAI,CAAC;IAAC,MAAM,EAAE,OAAO,CAAA;CAAE,GAC3D;IAAE,IAAI,EAAE,UAAU,CAAC;IAAC,EAAE,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,KAAK,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,GAC1D;IAAE,IAAI,EAAE,aAAa,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,OAAO,CAAC,EAAE,MAAM,CAAA;CAAE,GACxE;IAAE,IAAI,EAAE,aAAa,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GACrC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,MAAM,CAAA;CAAE,CAAC;AAIjC,MAAM,WAAW,UAAU;IACzB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,OAAO,CAAC;CACtB;AAID,MAAM,WAAW,aAAa;IAC5B,+CAA+C;IAC/C,SAAS,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC7B,iCAAiC;IACjC,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,iDAAiD;IACjD,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,+CAA+C;IAC/C,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,oEAAoE;IACpE,oBAAoB,CAAC,EAAE,MAAM,CAAC;IAC9B,8DAA8D;IAC9D,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,2CAA2C;IAC3C,cAAc,CAAC,EAAE,CAAC,MAAM,EAAE,YAAY,KAAK,IAAI,CAAC;CACjD;AAED,MAAM,MAAM,YAAY,GACpB,YAAY,GACZ,WAAW,GACX,cAAc,GACd,cAAc,CAAC;AAEnB,MAAM,WAAW,QAAQ;IACvB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,GAAG,WAAW,CAAC;IAC3B,QAAQ,CAAC,EAAE,QAAQ,EAAE,CAAC;CACvB"}

package/dist/types.js

@@ -0,0 +1,3 @@
+// ─── Message types (browser → extension) ─────────────────────────────────────
+export {};
+//# sourceMappingURL=types.js.map

package/dist/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,gFAAgF"}

package/dist-cjs/bridge.js

@@ -0,0 +1,364 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DevlinkBridge = void 0;
+const cache_1 = require("./cache");
+const PROTOCOL_VERSION = '1.0';
+const DEFAULT_PORTS = [7100, 7101, 7102, 7103, 7104];
+const PORT_RANGE_DEFAULT = [7100, 7200];
+class DevlinkBridge {
+    constructor(opts = {}) {
+        var _a, _b, _c, _d, _e, _f;
+        this.ws = null;
+        this.status = 'disconnected';
+        this.pending = new Map();
+        this.fileHandlers = new Map();
+        this.deleteHandlers = new Map();
+        this.statusHandlers = new Set();
+        this.eventHandlers = new Map();
+        this.cache = new cache_1.FileCache();
+        this.reconnectAttempts = 0;
+        this.reconnectTimer = null;
+        this.heartbeatTimer = null;
+        this.missedPongs = 0;
+        this.activePort = null;
+        this.lastWriteId = null;
+        this.workspaceRoot = null;
+        this.destroyed = false;
+        this.opts = {
+            portRange: (_a = opts.portRange) !== null && _a !== void 0 ? _a : PORT_RANGE_DEFAULT,
+            port: (_b = opts.port) !== null && _b !== void 0 ? _b : 0,
+            heartbeatMs: (_c = opts.heartbeatMs) !== null && _c !== void 0 ? _c : 5000,
+            timeoutMs: (_d = opts.timeoutMs) !== null && _d !== void 0 ? _d : 10000,
+            maxReconnectAttempts: (_e = opts.maxReconnectAttempts) !== null && _e !== void 0 ? _e : Infinity,
+            reconnectBaseMs: (_f = opts.reconnectBaseMs) !== null && _f !== void 0 ? _f : 500,
+            onStatusChange: opts.onStatusChange,
+        };
+        this.clientId = `devlink-${Math.random().toString(36).slice(2, 10)}`;
+        this.connect();
+    }
+    // ─── Connection lifecycle ───────────────────────────────────────────────────
+    async connect() {
+        if (this.destroyed)
+            return;
+        this.setStatus('connecting');
+        const port = await this.findOpenPort();
+        if (port === null) {
+            console.warn('[devlink-bridge] No VSCode extension found on ports', this.opts.portRange);
+            this.scheduleReconnect();
+            return;
+        }
+        this.activePort = port;
+        const url = `ws://127.0.0.1:${port}`;
+        try {
+            this.ws = new WebSocket(url);
+        }
+        catch {
+            this.scheduleReconnect();
+            return;
+        }
+        this.ws.onopen = () => {
+            this.reconnectAttempts = 0;
+            this.missedPongs = 0;
+            this.send({ type: 'handshake', protocolVersion: PROTOCOL_VERSION, clientId: this.clientId });
+            this.startHeartbeat();
+        };
+        this.ws.onmessage = (event) => {
+            try {
+                const msg = JSON.parse(event.data);
+                this.handleMessage(msg);
+            }
+            catch (e) {
+                console.error('[devlink-bridge] Failed to parse message:', e);
+            }
+        };
+        this.ws.onclose = () => {
+            this.stopHeartbeat();
+            this.rejectAllPending('Connection closed');
+            if (!this.destroyed)
+                this.scheduleReconnect();
+        };
+        this.ws.onerror = () => {
+            // onerror is always followed by onclose, so we handle there
+        };
+    }
+    async findOpenPort() {
+        // Try specific port first if provided
+        if (this.opts.port) {
+            if (await this.canConnect(this.opts.port))
+                return this.opts.port;
+        }
+        // Try default ports first (fast path)
+        for (const p of DEFAULT_PORTS) {
+            if (await this.canConnect(p))
+                return p;
+        }
+        // Full range scan
+        const [min, max] = this.opts.portRange;
+        for (let p = min; p <= max; p++) {
+            if (DEFAULT_PORTS.includes(p))
+                continue; // already tried
+            if (await this.canConnect(p))
+                return p;
+        }
+        return null;
+    }
+    canConnect(port) {
+        return new Promise(resolve => {
+            const ws = new WebSocket(`ws://127.0.0.1:${port}`);
+            const timer = setTimeout(() => { ws.close(); resolve(false); }, 2000);
+            ws.onopen = () => { clearTimeout(timer); ws.close(); resolve(true); };
+            ws.onerror = () => { clearTimeout(timer); resolve(false); };
+        });
+    }
+    scheduleReconnect() {
+        if (this.destroyed)
+            return;
+        if (this.reconnectAttempts >= this.opts.maxReconnectAttempts) {
+            this.setStatus('disconnected');
+            return;
+        }
+        this.setStatus('reconnecting');
+        this.reconnectAttempts++;
+        // Exponential backoff capped at 30s
+        const delay = Math.min(this.opts.reconnectBaseMs * Math.pow(2, this.reconnectAttempts - 1), 30000);
+        this.reconnectTimer = setTimeout(() => this.connect(), delay);
+    }
+    startHeartbeat() {
+        this.stopHeartbeat();
+        this.heartbeatTimer = setInterval(() => {
+            var _a;
+            if (this.missedPongs >= 2) {
+                // Extension is gone — force reconnect
+                (_a = this.ws) === null || _a === void 0 ? void 0 : _a.close();
+                return;
+            }
+            this.missedPongs++;
+            this.send({ type: 'ping', id: `ping-${Date.now()}` });
+        }, this.opts.heartbeatMs);
+    }
+    stopHeartbeat() {
+        if (this.heartbeatTimer) {
+            clearInterval(this.heartbeatTimer);
+            this.heartbeatTimer = null;
+        }
+    }
+    // ─── Message handling ───────────────────────────────────────────────────────
+    handleMessage(msg) {
+        var _a, _b;
+        switch (msg.type) {
+            case 'handshakeAck': {
+                this.workspaceRoot = msg.workspaceRoot;
+                this.setStatus('connected');
+                // Re-establish watchers for all files that were being watched before disconnect
+                this.restoreWatchers();
+                break;
+            }
+            case 'response': {
+                const pending = this.pending.get(msg.id);
+                if (!pending)
+                    return;
+                clearTimeout(pending.timer);
+                this.pending.delete(msg.id);
+                if (msg.ok) {
+                    pending.resolve(msg.result);
+                }
+                else {
+                    pending.reject(new Error(msg.error));
+                }
+                break;
+            }
+            case 'fileChanged': {
+                // Dedup our own saves — if writeId matches last write, skip UI notification
+                const updated = this.cache.update(msg.path, msg.content, (_a = msg.writeId) !== null && _a !== void 0 ? _a : undefined, (_b = this.lastWriteId) !== null && _b !== void 0 ? _b : undefined);
+                if (updated) {
+                    // Notify all registered handlers for this path
+                    const handlers = this.fileHandlers.get(msg.path);
+                    handlers === null || handlers === void 0 ? void 0 : handlers.forEach(h => h(msg.path, msg.content));
+                }
+                break;
+            }
+            case 'fileDeleted': {
+                this.cache.delete(msg.path);
+                const handlers = this.deleteHandlers.get(msg.path);
+                handlers === null || handlers === void 0 ? void 0 : handlers.forEach(h => h(msg.path));
+                break;
+            }
+            case 'pong': {
+                this.missedPongs = 0;
+                break;
+            }
+        }
+    }
+    async restoreWatchers() {
+        const paths = this.cache.watchedPaths();
+        for (const path of paths) {
+            try {
+                await this.request('watchFile', { path });
+            }
+            catch {
+                // Non-fatal — file may have been deleted during disconnect
+            }
+        }
+    }
+    // ─── Core request/response ──────────────────────────────────────────────────
+    request(type, payload) {
+        return new Promise((resolve, reject) => {
+            if (this.status !== 'connected') {
+                reject(new Error(`[devlink-bridge] Not connected (status: ${this.status})`));
+                return;
+            }
+            const id = `${type}-${Date.now()}-${Math.random().toString(36).slice(2, 7)}`;
+            const timer = setTimeout(() => {
+                var _a;
+                this.pending.delete(id);
+                reject(new Error(`[devlink-bridge] Request timed out: ${type} ${(_a = payload.path) !== null && _a !== void 0 ? _a : ''}`));
+            }, this.opts.timeoutMs);
+            this.pending.set(id, {
+                resolve: resolve,
+                reject,
+                timer,
+            });
+            this.send({ type, id, ...payload });
+        });
+    }
+    send(msg) {
+        var _a;
+        if (((_a = this.ws) === null || _a === void 0 ? void 0 : _a.readyState) === WebSocket.OPEN) {
+            this.ws.send(JSON.stringify(msg));
+        }
+    }
+    rejectAllPending(reason) {
+        for (const [id, pending] of this.pending) {
+            clearTimeout(pending.timer);
+            pending.reject(new Error(`[devlink-bridge] ${reason}`));
+            this.pending.delete(id);
+        }
+    }
+    setStatus(status) {
+        var _a, _b;
+        if (this.status === status)
+            return;
+        this.status = status;
+        (_b = (_a = this.opts).onStatusChange) === null || _b === void 0 ? void 0 : _b.call(_a, status);
+        this.statusHandlers.forEach(h => h(status));
+    }
+    // ─── Public API ─────────────────────────────────────────────────────────────
+    /** Read a file. Returns cached content if available, otherwise fetches. */
+    async readFile(path) {
+        const cached = this.cache.getContent(path);
+        if (cached !== undefined)
+            return cached;
+        const content = await this.request('readFile', { path });
+        this.cache.set(path, content, false);
+        return content;
+    }
+    /**
+     * Write a file. Debounce on the caller side (500ms recommended).
+     * The extension will push the change back via fileChanged,
+     * but we dedup it so the editor doesn't re-render its own save.
+     */
+    async writeFile(path, content) {
+        var _a, _b;
+        // Generate a writeId to dedup the incoming push
+        const writeId = `write-${Date.now()}-${Math.random().toString(36).slice(2, 7)}`;
+        this.lastWriteId = writeId;
+        // Optimistically update cache so the editor stays responsive
+        this.cache.set(path, content, (_b = (_a = this.cache.get(path)) === null || _a === void 0 ? void 0 : _a.watchActive) !== null && _b !== void 0 ? _b : false);
+        await this.request('writeFile', { path, content, writeId });
+    }
+    /** Read a directory tree */
+    async readDir(path, recursive = false) {
+        return this.request('readDir', { path, recursive });
+    }
+    /**
+     * Watch a file for changes pushed from the extension.
+     * Handler is called whenever the file changes on disk.
+     * Returns an unwatch function.
+     */
+    async watchFile(path, handler) {
+        var _a;
+        if (!this.fileHandlers.has(path)) {
+            this.fileHandlers.set(path, new Set());
+        }
+        this.fileHandlers.get(path).add(handler);
+        if (!((_a = this.cache.get(path)) === null || _a === void 0 ? void 0 : _a.watchActive)) {
+            await this.request('watchFile', { path });
+            this.cache.markWatched(path);
+        }
+        return () => this.unwatchFile(path, handler);
+    }
+    /** Watch a file for deletion */
+    onFileDeleted(path, handler) {
+        if (!this.deleteHandlers.has(path)) {
+            this.deleteHandlers.set(path, new Set());
+        }
+        this.deleteHandlers.get(path).add(handler);
+        return () => {
+            var _a;
+            (_a = this.deleteHandlers.get(path)) === null || _a === void 0 ? void 0 : _a.delete(handler);
+        };
+    }
+    async unwatchFile(path, handler) {
+        const handlers = this.fileHandlers.get(path);
+        if (!handlers)
+            return;
+        handlers.delete(handler);
+        if (handlers.size === 0) {
+            this.fileHandlers.delete(path);
+            this.cache.markUnwatched(path);
+            try {
+                await this.request('unwatchFile', { path });
+            }
+            catch {
+                // Non-fatal
+            }
+        }
+    }
+    /** Subscribe to arbitrary events from the bridge server */
+    on(type, handler) {
+        if (!this.eventHandlers.has(type)) {
+            this.eventHandlers.set(type, new Set());
+        }
+        this.eventHandlers.get(type).add(handler);
+        return () => { var _a; return (_a = this.eventHandlers.get(type)) === null || _a === void 0 ? void 0 : _a.delete(handler); };
+    }
+    /** Send an event to the bridge server without expecting a response */
+    publish(type, payload) {
+        this.send({ type, ...payload });
+    }
+    /** Subscribe to connection status changes */
+    onStatusChange(handler) {
+        this.statusHandlers.add(handler);
+        handler(this.status); // emit current status immediately
+        return () => this.statusHandlers.delete(handler);
+    }
+    /** Current connection status */
+    getStatus() {
+        return this.status;
+    }
+    /** Workspace root path (available after handshake) */
+    getWorkspaceRoot() {
+        return this.workspaceRoot;
+    }
+    /** Active port (available after connection) */
+    getActivePort() {
+        return this.activePort;
+    }
+    /** Cache snapshot for debugging */
+    getCacheSnapshot() {
+        return this.cache.snapshot();
+    }
+    /** Destroy the bridge — cleans up all timers and closes the socket */
+    destroy() {
+        var _a;
+        this.destroyed = true;
+        this.stopHeartbeat();
+        if (this.reconnectTimer)
+            clearTimeout(this.reconnectTimer);
+        this.rejectAllPending('Bridge destroyed');
+        (_a = this.ws) === null || _a === void 0 ? void 0 : _a.close();
+        this.ws = null;
+        this.setStatus('disconnected');
+    }
+}
+exports.DevlinkBridge = DevlinkBridge;

package/dist-cjs/cache.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileCache = void 0;
+class FileCache {
+    constructor(maxSize = 500) {
+        this.store = new Map();
+        this.maxSize = maxSize;
+    }
+    get(path) {
+        return this.store.get(path);
+    }
+    getContent(path) {
+        var _a;
+        return (_a = this.store.get(path)) === null || _a === void 0 ? void 0 : _a.content;
+    }
+    has(path) {
+        return this.store.has(path);
+    }
+    set(path, content, watchActive = false) {
+        // Evict oldest entry if at capacity
+        if (!this.store.has(path) && this.store.size >= this.maxSize) {
+            const oldest = this.store.keys().next().value;
+            if (oldest)
+                this.store.delete(oldest);
+        }
+        const existing = this.store.get(path);
+        const entry = {
+            content,
+            version: existing ? existing.version + 1 : 1,
+            lastFetched: Date.now(),
+            watchActive,
+        };
+        this.store.set(path, entry);
+        return entry;
+    }
+    // Called when extension pushes a file change
+    // Returns false if writeId matches the last write (dedup own saves)
+    update(path, content, writeId, lastWriteId) {
+        var _a;
+        if (writeId && writeId === lastWriteId) {
+            // This push was triggered by our own save — skip
+            return false;
+        }
+        const existing = this.store.get(path);
+        const entry = {
+            content,
+            version: existing ? existing.version + 1 : 1,
+            lastFetched: Date.now(),
+            watchActive: (_a = existing === null || existing === void 0 ? void 0 : existing.watchActive) !== null && _a !== void 0 ? _a : true,
+        };
+        this.store.set(path, entry);
+        return true;
+    }
+    delete(path) {
+        this.store.delete(path);
+    }
+    markWatched(path) {
+        const entry = this.store.get(path);
+        if (entry)
+            entry.watchActive = true;
+    }
+    markUnwatched(path) {
+        const entry = this.store.get(path);
+        if (entry)
+            entry.watchActive = false;
+    }
+    // Returns all currently watched paths (needed after reconnect)
+    watchedPaths() {
+        const paths = [];
+        for (const [path, entry] of this.store) {
+            if (entry.watchActive)
+                paths.push(path);
+        }
+        return paths;
+    }
+    clear() {
+        this.store.clear();
+    }
+    size() {
+        return this.store.size;
+    }
+    // Debug snapshot
+    snapshot() {
+        const out = {};
+        for (const [path, entry] of this.store) {
+            out[path] = {
+                version: entry.version,
+                size: entry.content.length,
+                watched: entry.watchActive,
+            };
+        }
+        return out;
+    }
+}
+exports.FileCache = FileCache;

package/dist-cjs/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileCache = exports.DevlinkBridge = void 0;
+var bridge_1 = require("./bridge");
+Object.defineProperty(exports, "DevlinkBridge", { enumerable: true, get: function () { return bridge_1.DevlinkBridge; } });
+var cache_1 = require("./cache");
+Object.defineProperty(exports, "FileCache", { enumerable: true, get: function () { return cache_1.FileCache; } });

package/dist-cjs/types.js

@@ -0,0 +1,3 @@
+"use strict";
+// ─── Message types (browser → extension) ─────────────────────────────────────
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -0,0 +1,77 @@
+{
+  "name": "@rahul_ur/devlink-bridge",
+  "version": "1.0.0",
+  "description": "Browser SDK + local bridge server for devlink — connects your web app to VSCode over a local WebSocket",
+  "main": "dist-cjs/index.js",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "require": "./dist-cjs/index.js",
+      "import": "./dist/index.mjs",
+      "types": "./dist/index.d.ts"
+    },
+    "./server.mjs": "./server.mjs",
+    "./setup-devlink.mjs": "./setup-devlink.mjs"
+  },
+  "bin": {
+    "devlink-setup": "setup-devlink.mjs",
+    "devlink-server": "server.mjs"
+  },
+  "files": [
+    "dist",
+    "dist-cjs",
+    "server.mjs",
+    "setup-devlink.mjs",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json && tsc -p tsconfig.cjs.json && node scripts/rename-esm.mjs",
+    "dev": "tsc --watch",
+    "test": "jest --no-coverage --passWithNoTests",
+    "prepublishOnly": "npm run build && npm test && npm pack --dry-run"
+  },
+  "keywords": [
+    "devlink",
+    "bridge",
+    "websocket",
+    "vscode",
+    "devtools",
+    "inspector"
+  ],
+  "license": "MIT",
+  "dependencies": {
+    "ws": "^8.20.0"
+  },
+  "devDependencies": {
+    "@types/jest": "^29.5.0",
+    "@types/node": "^20.0.0",
+    "@types/ws": "^8.5.0",
+    "jest": "^29.7.0",
+    "ts-jest": "^29.1.0",
+    "typescript": "^5.2.0"
+  },
+  "jest": {
+    "preset": "ts-jest",
+    "testEnvironment": "node",
+    "transform": {
+      "^.+\\.tsx?$": [
+        "ts-jest",
+        {
+          "tsconfig": {
+            "module": "commonjs"
+          }
+        }
+      ]
+    }
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/BiginerCoder/Devlink-Doc.git"
+  },
+  "author": "rahul urmaliya",
+  "bugs": {
+    "url": "https://github.com/BiginerCoder/Devlink-Doc/issues"
+  },
+  "homepage": "https://github.com/BiginerCoder/Devlink-Doc#readme"
+}