@jobshimo/browser-link 0.1.0 → 0.4.0

package/README.md

@@ -3,12 +3,12 @@
 > ⚠️ **Read this before installing**
 >
 > This package opens a bridge between your MCP client (Claude Code,
-> OpenCode, …) and the Chrome tabs you explicitly enable through a
-> companion extension. On every tab where you press "Conectar" in the
-> extension popup, the agent can read its DOM, click, type, run
-> arbitrary JavaScript, and follow links — including any logged-in
-> session, saved card, wallet, banking page or admin panel that tab is
-> currently showing.
+> OpenCode, GitHub Copilot CLI…) and the Chrome tabs you explicitly
+> enable through a companion extension. On every tab where you press
+> "Conectar" in the extension popup, the agent can read its DOM, click,
+> type, run arbitrary JavaScript, and follow links — including any
+> logged-in session, saved card, wallet, banking page or admin panel
+> that tab is currently showing.
 >
 > Treat the agent like a junior dev with remote control of those tabs.
 > Only enable tabs where you would let an automated process act on your
@@ -16,10 +16,10 @@
 > every action the agent performs on the tabs you explicitly enable.
 
 MCP server that bridges any MCP-compatible client (Claude Code, OpenCode,
-and friends) to the Chrome tabs you grant access to, through a small
-WebSocket relay and a companion Chrome extension. Ships with a persistent
-UI map so the agent remembers selectors, flows and gotchas it learned
-about each app, across sessions.
+GitHub Copilot CLI, and friends) to the Chrome tabs you grant access to,
+through a small WebSocket relay and a companion Chrome extension. Ships
+with a persistent UI map so the agent remembers selectors, flows and
+gotchas it learned about each app, across sessions.
 
 ## Install
 
@@ -31,18 +31,16 @@ This puts the `browser-link` binary on your PATH on macOS, Linux and Windows.
 
 ## Set it up
 
-The fastest path is the interactive menu (built on `@clack/prompts` —
-flicker-free in PowerShell, Windows Terminal, macOS Terminal, iTerm, every
-Linux TTY):
+The fastest path is the interactive UI — a full-screen [Ink](https://github.com/vadimdemedes/ink)-based app with a pinned header, live status of every MCP client, and sub-screens that swap in place (no flicker, no scroll-off):
 
 ```bash
 browser-link
 ```
 
 That opens the welcome / disclaimer screen (English or Spanish), and then
-the setup menu where you can register browser-link with **Claude Code** or
-**OpenCode**, see the Chrome extension install steps, run a doctor
-diagnose, and open the about / help page.
+the setup menu where you can register `browser-link` with **Claude Code**,
+**OpenCode**, or **GitHub Copilot CLI**, see the Chrome extension install
+steps, run a doctor diagnose, and open the about / help page.
 
 If you prefer direct commands:
 
@@ -50,12 +48,50 @@ If you prefer direct commands:
 browser-link install                       # register in every detected client
 browser-link install --client claude       # register only in Claude Code
 browser-link install --client opencode     # register only in OpenCode
+browser-link install --client copilot      # register only in GitHub Copilot CLI
 browser-link uninstall --client opencode   # remove from one client
 browser-link extension                     # show the Chrome extension assets path + steps
 browser-link doctor                        # diagnose current setup
+browser-link tools                         # show which MCP tools are enabled / disabled
+browser-link tools disable browser.evaluate
+browser-link tools preset readonly         # all | readonly | no-eval | no-map
+browser-link updates                       # check the npm registry for a newer version
 browser-link about                         # what this is, how it works, every tool
 ```
 
+## Per-tool permissions
+
+`browser-link` exposes 17 MCP tools by default — 10 browser-bridge tools,
+6 UI-map tools, and `browser.events` for bridge traceability. You can
+disable any subset per machine, either through the **Permissions** screen
+in the interactive menu (toggle with Space, apply a preset with Enter,
+save with `s`) or through the scriptable `browser-link tools` subcommand.
+Available presets: `all` (default), `readonly`, `no-eval`, `no-map`.
+Changes take effect the next time your MCP client starts the server.
+
+## Multi-agent mode
+
+By default only one MCP client can have browser-link active at a time
+(EADDRINUSE on the second). Enable multi-agent mode and the second
+`browser-link` spawn becomes a proxy that forwards MCP requests to the
+first via `127.0.0.1:17530`, with the same kernel-level process binding
+the WS port already uses. All connected clients share the same Chrome
+tabs and persistent UI map.
+
+```bash
+browser-link multi-agent enable
+browser-link multi-agent auto-reelect enable     # optional
+```
+
+With `auto-reelect` on, secondary proxies survive the primary closing:
+they enter a 5-second reconnect window, return `-32001 "temporarily
+unavailable"` for in-flight requests, and hot-swap to the fresh primary
+once it appears. The agent self-recovers from stale tab ids via the new
+`browser.events` tool, which surfaces a ring buffer of bridge lifecycle
+events (`primary-elected`, `tab-registered`, `tab-disconnected`,
+`tab-renamed`). The Chrome extension preserves the per-tab id across
+primary swaps via `chrome.storage.session`.
+
 After `install`, restart the MCP client so it picks up the new entry.
 After `extension`, follow the printed steps to load the unpacked extension
 in Chrome. Then click "Conectar" on every tab you want the agent to reach
@@ -63,12 +99,13 @@ in Chrome. Then click "Conectar" on every tab you want the agent to reach
 
 ## Supported MCP clients
 
-| Client                                            | Config file written                                            |
-| ------------------------------------------------- | -------------------------------------------------------------- |
-| [Claude Code](https://docs.claude.com/claude-code) | `~/.claude.json` (`%USERPROFILE%\.claude.json` on Windows)     |
-| [OpenCode](https://opencode.ai)                   | `~/.config/opencode/opencode.json` on **every** OS (Win incl.) |
+| Client                                                               | Config file written                                              |
+| -------------------------------------------------------------------- | ---------------------------------------------------------------- |
+| [Claude Code](https://docs.claude.com/claude-code)                   | `~/.claude.json` (`%USERPROFILE%\.claude.json` on Windows)       |
+| [OpenCode](https://opencode.ai)                                      | `~/.config/opencode/opencode.json` on **every** OS (Win incl.)   |
+| [GitHub Copilot CLI](https://docs.github.com/en/copilot/copilot-cli) | `~/.copilot/mcp-config.json` (override via `COPILOT_HOME` env)   |
 
-Both registrations are idempotent — re-running `install` updates the
+Every registration is idempotent — re-running `install` updates the
 entry instead of duplicating it. `uninstall --client <id>` removes it
 cleanly without touching anything else in the file.
 

package/dist/bridge/client.d.ts

@@ -0,0 +1,101 @@
+import { type Interface } from 'node:readline';
+/** Raised when the proxy cannot complete the IPC handshake. */
+export declare class HandshakeError extends Error {
+    constructor(message: string);
+}
+export interface ConnectOptions {
+    host?: string;
+    port?: number;
+    /** How long to wait for a hello-ack after sending the hello. */
+    handshakeTimeoutMs?: number;
+}
+export interface ConnectionInfo {
+    sessionId: string;
+    version: string;
+}
+/** Minimal IPC client. Owns the TCP socket, handles framing, runs the
+ * handshake, dispatches mcp.response frames back to whoever sent the
+ * matching mcp.request. */
+export declare class IpcClient {
+    private socket;
+    private buffer;
+    private nextRequestId;
+    private pendingRequests;
+    private closeListeners;
+    private notificationListeners;
+    private closed;
+    /** Open the TCP connection, perform the handshake, and resolve with the
+     * session info from the primary's hello-ack. On any handshake failure,
+     * rejects with HandshakeError and tears down the socket. */
+    connect(token: string, opts?: ConnectOptions): Promise<ConnectionInfo>;
+    private handshakeReceiver;
+    /** Forward a JSON-RPC request as an mcp.request frame. Resolves with the
+     * primary's JSON-RPC response payload. Rejects if the socket closes. */
+    sendMcpRequest(jsonRpcPayload: unknown): Promise<unknown>;
+    /** Forward a JSON-RPC notification as an mcp.notification frame. Fire-
+     * and-forget — notifications have no response in JSON-RPC. */
+    sendMcpNotification(jsonRpcPayload: unknown): void;
+    /** Register a callback invoked when the IPC connection drops. The
+     * `reason` argument distinguishes a primary-closing broadcast from a
+     * plain remote close so callers can decide to re-elect vs exit. */
+    onClose(cb: (reason: 'remote' | 'local' | 'primary-closing') => void): void;
+    /** Register a callback for unsolicited notifications from the primary
+     * (e.g. tools/list_changed in the future). */
+    onNotification(cb: (payload: unknown) => void): void;
+    /** Close the IPC connection. */
+    disconnect(): Promise<void>;
+    private ingest;
+    private handleFrame;
+    private onSocketClose;
+    private notifyClose;
+}
+export interface ProxyOptions {
+    input?: NodeJS.ReadableStream;
+    output?: NodeJS.WritableStream;
+    /** Called when the IPC connection drops and (if reelect was enabled)
+     * could not be re-established. After this fires the proxy is dead;
+     * callers usually want to exit the process. */
+    onClose?: (reason: 'remote' | 'local' | 'primary-closing') => void;
+    /** Override the token used in the hello. Tests pass this directly so
+     * they don't need to write a token file. Production reads it from disk. */
+    token?: string;
+    /** Override IPC endpoint. */
+    host?: string;
+    port?: number;
+    /** When true, instead of giving up on the first IPC drop, the proxy
+     * tries to reconnect to a fresh primary at the same IPC port for up to
+     * reelectTimeoutMs. During that window, any incoming JSON-RPC request
+     * from stdin gets an immediate "bridge unavailable" error response so
+     * the MCP client doesn't hang. Default: false. */
+    autoReelect?: boolean;
+    /** Total budget (ms) to wait for a new primary before giving up.
+     * Default: 5000. */
+    reelectTimeoutMs?: number;
+    /** Per-attempt interval (ms) between reconnect tries. Default: 200. */
+    reelectIntervalMs?: number;
+    /** Hook for tests: called whenever the proxy starts a reconnect
+     * attempt cycle. Production callers ignore. */
+    onReelectStart?: () => void;
+    /** Hook for tests: called when a reconnect cycle succeeds. */
+    onReelectSuccess?: () => void;
+    /** Hook for tests: called when a reconnect cycle exhausts the budget. */
+    onReelectExhausted?: () => void;
+}
+export interface ProxyHandle {
+    client: IpcClient;
+    stop(): Promise<void>;
+    /** Resolves once the IPC connection drops (any reason). */
+    closed: Promise<void>;
+}
+/** Read the token from disk and connect to the running primary, then plug
+ * stdin → IPC mcp.request and IPC mcp.response → stdout.
+ *
+ * When `autoReelect: true` is passed, the proxy survives IPC drops by
+ * waiting for a fresh primary to appear at the same port. During the
+ * wait, incoming JSON-RPC requests get an immediate error response so
+ * the MCP client never hangs on a missing reply. */
+export declare function runProxy(opts?: ProxyOptions): Promise<ProxyHandle>;
+/** Convenience: open a readline-style line iterator over a stream. Currently
+ * unused (we use a hand-rolled line buffer for symmetry with the server)
+ * but exported for future tooling. */
+export declare function readlines(stream: NodeJS.ReadableStream): Interface;

package/dist/bridge/client.js

@@ -0,0 +1,435 @@
+import { connect } from 'node:net';
+import { createInterface } from 'node:readline';
+import { IPC_HOST, IPC_PORT, IPC_PROTOCOL_VERSION, encodeFrame, parseFrame, } from './protocol.js';
+import { readToken } from './token.js';
+/**
+ * Proxy's side of the IPC bridge. The proxy is a thin browser-link process
+ * spawned by an MCP client (Claude / Copilot / OpenCode) that finds the WS
+ * port already taken — it forwards every MCP frame it gets on stdin to the
+ * primary via the IPC socket, and pipes responses back to stdout.
+ *
+ * Two flavours:
+ *  - IpcClient is the bare connection (used by tests and re-election).
+ *  - runProxy() wires IpcClient to stdin/stdout so the MCP client thinks
+ *    it is talking to a real server.
+ */
+function log(msg) {
+    console.error(`[browser-link proxy] ${msg}`);
+}
+/** Raised when the proxy cannot complete the IPC handshake. */
+export class HandshakeError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'HandshakeError';
+    }
+}
+/** Minimal IPC client. Owns the TCP socket, handles framing, runs the
+ * handshake, dispatches mcp.response frames back to whoever sent the
+ * matching mcp.request. */
+export class IpcClient {
+    socket = null;
+    buffer = '';
+    nextRequestId = 1;
+    pendingRequests = new Map();
+    closeListeners = [];
+    notificationListeners = [];
+    closed = false;
+    /** Open the TCP connection, perform the handshake, and resolve with the
+     * session info from the primary's hello-ack. On any handshake failure,
+     * rejects with HandshakeError and tears down the socket. */
+    async connect(token, opts = {}) {
+        const host = opts.host ?? IPC_HOST;
+        const port = opts.port ?? IPC_PORT;
+        const handshakeTimeoutMs = opts.handshakeTimeoutMs ?? 4000;
+        const socket = await new Promise((resolve, reject) => {
+            const s = connect({ host, port });
+            s.once('connect', () => resolve(s));
+            s.once('error', (err) => reject(err));
+        });
+        this.socket = socket;
+        socket.on('data', (chunk) => this.ingest(chunk));
+        socket.on('close', () => this.onSocketClose('remote'));
+        socket.on('error', (err) => log(`Socket error: ${err.message}`));
+        // Send hello, wait for ack or reject or timeout.
+        const ack = await new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                reject(new HandshakeError('Handshake timed out — primary did not reply.'));
+            }, handshakeTimeoutMs);
+            const onFirstFrame = (frame) => {
+                clearTimeout(timer);
+                if (frame.kind === 'hello-ack') {
+                    resolve({ sessionId: frame.sessionId, version: frame.version });
+                    return;
+                }
+                if (frame.kind === 'hello-reject') {
+                    reject(new HandshakeError(`Primary rejected: ${frame.reason}`));
+                    return;
+                }
+                reject(new HandshakeError(`Unexpected first frame: ${frame.kind}`));
+            };
+            this.handshakeReceiver = onFirstFrame;
+            try {
+                socket.write(encodeFrame({ kind: 'hello', version: IPC_PROTOCOL_VERSION, token }));
+            }
+            catch (err) {
+                clearTimeout(timer);
+                reject(err instanceof Error ? err : new Error(String(err)));
+            }
+        }).catch((err) => {
+            this.disconnect().catch(() => {
+                /* ignore */
+            });
+            throw err;
+        });
+        this.handshakeReceiver = null;
+        log(`Handshake ok — session=${ack.sessionId}`);
+        return ack;
+    }
+    handshakeReceiver = null;
+    /** Forward a JSON-RPC request as an mcp.request frame. Resolves with the
+     * primary's JSON-RPC response payload. Rejects if the socket closes. */
+    sendMcpRequest(jsonRpcPayload) {
+        if (!this.socket || this.closed) {
+            return Promise.reject(new Error('Proxy is not connected.'));
+        }
+        const requestId = this.nextRequestId++;
+        return new Promise((resolve, reject) => {
+            this.pendingRequests.set(requestId, resolve);
+            const onCloseHandler = () => {
+                if (this.pendingRequests.delete(requestId)) {
+                    reject(new Error('Primary connection closed while a request was in flight.'));
+                }
+            };
+            this.onClose(onCloseHandler);
+            try {
+                this.socket.write(encodeFrame({ kind: 'mcp.request', requestId, payload: jsonRpcPayload }));
+            }
+            catch (err) {
+                this.pendingRequests.delete(requestId);
+                reject(err instanceof Error ? err : new Error(String(err)));
+            }
+        });
+    }
+    /** Forward a JSON-RPC notification as an mcp.notification frame. Fire-
+     * and-forget — notifications have no response in JSON-RPC. */
+    sendMcpNotification(jsonRpcPayload) {
+        if (!this.socket || this.closed)
+            return;
+        try {
+            this.socket.write(encodeFrame({ kind: 'mcp.notification', payload: jsonRpcPayload }));
+        }
+        catch {
+            /* socket gone; close handler will fire */
+        }
+    }
+    /** Register a callback invoked when the IPC connection drops. The
+     * `reason` argument distinguishes a primary-closing broadcast from a
+     * plain remote close so callers can decide to re-elect vs exit. */
+    onClose(cb) {
+        this.closeListeners.push(cb);
+    }
+    /** Register a callback for unsolicited notifications from the primary
+     * (e.g. tools/list_changed in the future). */
+    onNotification(cb) {
+        this.notificationListeners.push(cb);
+    }
+    /** Close the IPC connection. */
+    async disconnect() {
+        if (this.closed)
+            return;
+        this.closed = true;
+        if (this.socket) {
+            const s = this.socket;
+            this.socket = null;
+            try {
+                s.end();
+            }
+            catch {
+                /* ignore */
+            }
+            s.destroy();
+            // Fire close listeners with reason=local (we initiated it).
+            this.notifyClose('local');
+        }
+    }
+    ingest(chunk) {
+        this.buffer += chunk.toString('utf8');
+        let nl;
+        while ((nl = this.buffer.indexOf('\n')) >= 0) {
+            const line = this.buffer.slice(0, nl);
+            this.buffer = this.buffer.slice(nl + 1);
+            if (line.length === 0)
+                continue;
+            const frame = parseFrame(line);
+            if (!frame) {
+                log('Invalid frame from primary; dropping.');
+                continue;
+            }
+            this.handleFrame(frame);
+        }
+    }
+    handleFrame(frame) {
+        if (this.handshakeReceiver) {
+            this.handshakeReceiver(frame);
+            return;
+        }
+        switch (frame.kind) {
+            case 'mcp.response': {
+                const resolve = this.pendingRequests.get(frame.requestId);
+                if (resolve) {
+                    this.pendingRequests.delete(frame.requestId);
+                    resolve(frame.payload);
+                }
+                return;
+            }
+            case 'mcp.notification': {
+                for (const cb of this.notificationListeners)
+                    cb(frame.payload);
+                return;
+            }
+            case 'ping': {
+                try {
+                    this.socket?.write(encodeFrame({ kind: 'pong' }));
+                }
+                catch {
+                    /* socket gone */
+                }
+                return;
+            }
+            case 'pong': {
+                // Future: we can send our own pings if needed. Today the primary
+                // initiates the heartbeat; pong from us → primary.
+                return;
+            }
+            case 'primary-closing': {
+                log(`Primary signalled close (${frame.reason ?? 'no reason'}).`);
+                this.notifyClose('primary-closing');
+                return;
+            }
+            default:
+                return;
+        }
+    }
+    onSocketClose(reason) {
+        if (this.closed)
+            return;
+        this.closed = true;
+        log('Socket closed by primary.');
+        this.notifyClose(reason);
+    }
+    notifyClose(reason) {
+        // Reject every in-flight request first so callers don't hang.
+        for (const resolve of this.pendingRequests.values()) {
+            // We resolve with a JSON-RPC error envelope so the MCP client gets
+            // a tool error instead of a stuck promise.
+            resolve({
+                jsonrpc: '2.0',
+                id: null,
+                error: { code: -32000, message: 'browser-link primary disconnected.' },
+            });
+        }
+        this.pendingRequests.clear();
+        for (const cb of this.closeListeners.splice(0)) {
+            try {
+                cb(reason);
+            }
+            catch (err) {
+                log(`Close listener threw: ${err instanceof Error ? err.message : String(err)}`);
+            }
+        }
+    }
+}
+/** Read the token from disk and connect to the running primary, then plug
+ * stdin → IPC mcp.request and IPC mcp.response → stdout.
+ *
+ * When `autoReelect: true` is passed, the proxy survives IPC drops by
+ * waiting for a fresh primary to appear at the same port. During the
+ * wait, incoming JSON-RPC requests get an immediate error response so
+ * the MCP client never hangs on a missing reply. */
+export async function runProxy(opts = {}) {
+    const input = opts.input ?? process.stdin;
+    const output = opts.output ?? process.stdout;
+    const autoReelect = opts.autoReelect === true;
+    const reelectTimeoutMs = opts.reelectTimeoutMs ?? 5000;
+    const reelectIntervalMs = opts.reelectIntervalMs ?? 200;
+    const initialToken = opts.token ?? readToken();
+    if (!initialToken) {
+        throw new Error('Multi-agent token not found. The primary browser-link instance is not running with multi-agent enabled.');
+    }
+    let client = new IpcClient();
+    await client.connect(initialToken, { host: opts.host, port: opts.port });
+    /* When the IPC drops AND autoReelect is on, we enter "reconnecting"
+     * mode. While reconnecting, the data pipe stays attached but requests
+     * are answered immediately with an error envelope so the MCP client
+     * does not stall on a missing reply. */
+    let reconnecting = false;
+    let stopped = false;
+    let closedResolve = () => { };
+    const closed = new Promise((resolve) => {
+        closedResolve = resolve;
+    });
+    const fail = (reason) => {
+        if (stopped)
+            return;
+        stopped = true;
+        input.off?.('data', onData);
+        if (opts.onClose) {
+            try {
+                opts.onClose(reason);
+            }
+            catch (err) {
+                log(`onClose handler threw: ${err instanceof Error ? err.message : String(err)}`);
+            }
+        }
+        closedResolve();
+    };
+    // Set up the input pipe. We can't use readline.createInterface on a raw
+    // stream that has already been data-event-attached, but we can use a
+    // simple line buffer like the server side.
+    let lineBuffer = '';
+    const onData = (chunk) => {
+        const text = typeof chunk === 'string' ? chunk : chunk.toString('utf8');
+        lineBuffer += text;
+        let nl;
+        while ((nl = lineBuffer.indexOf('\n')) >= 0) {
+            const line = lineBuffer.slice(0, nl).replace(/\r$/, '');
+            lineBuffer = lineBuffer.slice(nl + 1);
+            if (line.length === 0)
+                continue;
+            handleLine(line);
+        }
+    };
+    const handleLine = (line) => {
+        let msg;
+        try {
+            msg = JSON.parse(line);
+        }
+        catch {
+            output.write(JSON.stringify({
+                jsonrpc: '2.0',
+                id: null,
+                error: { code: -32700, message: 'Parse error in proxy input.' },
+            }) + '\n');
+            return;
+        }
+        if (!msg || typeof msg !== 'object')
+            return;
+        if (msg.id === undefined || msg.id === null) {
+            // Notification — fire and forget when connected; drop during reconnect.
+            if (!reconnecting)
+                client.sendMcpNotification(msg);
+            return;
+        }
+        if (reconnecting) {
+            // Fail fast so the MCP client can decide to retry.
+            output.write(JSON.stringify({
+                jsonrpc: '2.0',
+                id: msg.id,
+                error: {
+                    code: -32001,
+                    message: 'browser-link bridge temporarily unavailable (primary just closed; reconnecting).',
+                },
+            }) + '\n');
+            return;
+        }
+        client
+            .sendMcpRequest(msg)
+            .then((responsePayload) => {
+            output.write(JSON.stringify(responsePayload) + '\n');
+        })
+            .catch((err) => {
+            output.write(JSON.stringify({
+                jsonrpc: '2.0',
+                id: msg.id,
+                error: { code: -32000, message: err instanceof Error ? err.message : String(err) },
+            }) + '\n');
+        });
+    };
+    input.on('data', onData);
+    const wireCloseHandler = (c) => {
+        c.onClose(async (reason) => {
+            if (stopped)
+                return;
+            if (!autoReelect) {
+                fail(reason);
+                return;
+            }
+            // Enter reconnect mode and try to find a new primary.
+            reconnecting = true;
+            opts.onReelectStart?.();
+            log(`Primary closed (${reason}); reelect window opened for ${reelectTimeoutMs}ms.`);
+            const newClient = await reconnectLoop(opts.host, opts.port, reelectTimeoutMs, reelectIntervalMs);
+            if (stopped) {
+                if (newClient)
+                    await newClient.disconnect();
+                return;
+            }
+            if (!newClient) {
+                log('Reelect window exhausted; closing proxy.');
+                opts.onReelectExhausted?.();
+                reconnecting = false;
+                fail(reason);
+                return;
+            }
+            // Hot-swap clients. The old one is already torn down by its close
+            // handler chain; we just install the new one and wire it up.
+            log('Reconnected to new primary.');
+            opts.onReelectSuccess?.();
+            client = newClient;
+            reconnecting = false;
+            wireCloseHandler(client);
+        });
+    };
+    wireCloseHandler(client);
+    const stop = async () => {
+        stopped = true;
+        input.off?.('data', onData);
+        await client.disconnect();
+        closedResolve();
+    };
+    return {
+        get client() {
+            return client;
+        },
+        stop,
+        closed,
+    };
+}
+/** Repeatedly try to connect to the IPC port until success or budget
+ * expires. Re-reads the token on every attempt because a new primary
+ * rotates it on startup. Returns the connected client, or null on
+ * timeout. */
+async function reconnectLoop(host, port, totalBudgetMs, intervalMs) {
+    const deadline = Date.now() + totalBudgetMs;
+    // Generous handshake budget — Windows under load can take >200ms for a
+    // local socket round-trip and a too-tight ceiling makes reconnects flap.
+    const handshakeTimeoutMs = Math.min(1500, Math.max(800, intervalMs * 4));
+    while (Date.now() < deadline) {
+        await new Promise((r) => setTimeout(r, intervalMs));
+        const token = readToken();
+        if (!token)
+            continue;
+        const c = new IpcClient();
+        try {
+            await c.connect(token, { host, port, handshakeTimeoutMs });
+            return c;
+        }
+        catch {
+            try {
+                await c.disconnect();
+            }
+            catch {
+                /* ignore */
+            }
+            // Retry until deadline.
+        }
+    }
+    return null;
+}
+/** Convenience: open a readline-style line iterator over a stream. Currently
+ * unused (we use a hand-rolled line buffer for symmetry with the server)
+ * but exported for future tooling. */
+export function readlines(stream) {
+    return createInterface({ input: stream, crlfDelay: Infinity });
+}
+//# sourceMappingURL=client.js.map