@hwip/mcp-server 0.0.0-stage → 0.1.0

package/dist/trust-pins.js

@@ -0,0 +1,269 @@
+"use strict";
+/**
+ * Pinning the account's devices as a sender sees them (twin of the cli's `src/trust-pins.ts` and `src/trust-lock.ts`).
+ *
+ * `hwip_notify`, `hwip_file`, `hwip_ask` and `hwip_agent_send` read `GET /devices` before they seal. Every device that
+ * lists a key is pinned the first time it is seen, and a pin whose device now lists another key is replaced — with one
+ * warning, because a key that changed is also what a relay swapping the list looks like, and a record (`key-changes.ts`)
+ * the next tool result shows, since this server's stderr reaches nobody. Nothing here decides who is
+ * sealed for: the list does. The pins are what the cli listener holds a request against and what a person compares
+ * with `hwip trust`; trust never stops a send.
+ *
+ * The file is shared with the cli, which also keeps the listener's sealed-command numbers in it (`commands`,
+ * `commandKeys`). Every writer re-reads it under `trusted-devices.lock` and rewrites only its own part: here that is
+ * `devices` (and, for a replaced pin, the old key's command number carried into `commandKeys`, as the cli does), with
+ * every other field kept as it was. `sealedOnce` is read past and not written back.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.observeDevices = exports.withTrustLock = exports.readTrustFile = exports.MAX_PINNED_DEVICES = exports.DEVICE_ID = exports.TRUST_PATH = void 0;
+const node_crypto_1 = require("node:crypto");
+const node_fs_1 = require("node:fs");
+const node_os_1 = require("node:os");
+const node_path_1 = require("node:path");
+const crypto_js_1 = require("./crypto.js");
+const key_changes_js_1 = require("./key-changes.js");
+/** The cli listener's state file. */
+exports.TRUST_PATH = (0, node_path_1.join)((0, node_os_1.homedir)(), '.hwip', 'trusted-devices.json');
+/** A device id as the app, the cli and the server mint them. */
+exports.DEVICE_ID = /^[A-Za-z0-9_-]{1,64}$/;
+/** Devices pinned at most: a list padded with made-up devices must not grow the file one rewrite at a time. */
+exports.MAX_PINNED_DEVICES = 64;
+const TRUST_VERSION = 1;
+/** A lock older than this was left by a process that died. */
+const STALE_MS = 10_000;
+const WAIT_MS = 1_000;
+const POLL_MS = 20;
+const isCommandNumber = (n) => typeof n === 'number' && Number.isSafeInteger(n) && n >= 0;
+/** Judged as the cli's `readTrustState` judges it, so the two never disagree about the same file. */
+const parseTrust = (text) => {
+    const raw = JSON.parse(text);
+    if (typeof raw !== 'object' || raw === null || Array.isArray(raw))
+        return null;
+    if (!('version' in raw) || raw.version !== TRUST_VERSION)
+        return null;
+    if (!('devices' in raw) || typeof raw.devices !== 'object' || raw.devices === null)
+        return null;
+    for (const pin of Object.values(raw.devices)) {
+        const isPin = typeof pin === 'object' && pin !== null
+            && 'publicKey' in pin && typeof pin.publicKey === 'string'
+            && 'pinnedAt' in pin && typeof pin.pinnedAt === 'string';
+        if (!isPin)
+            return null;
+    }
+    // Absent from files written before sealed commands; when there, as the cli reads it.
+    if ('commands' in raw) {
+        if (typeof raw.commands !== 'object' || raw.commands === null)
+            return null;
+        if (!Object.values(raw.commands).every(isCommandNumber))
+            return null;
+    }
+    return raw;
+};
+/** The trust file: a missing one is empty, one that will not read or parse is `null`, never a guess. */
+const readTrustFile = (path) => {
+    let text;
+    try {
+        text = (0, node_fs_1.readFileSync)(path, 'utf-8');
+    }
+    catch (err) {
+        return err.code === 'ENOENT' ? { version: TRUST_VERSION, devices: {} } : null; // err.code is how node names a missing file
+    }
+    try {
+        return parseTrust(text);
+    }
+    catch {
+        return null;
+    }
+};
+exports.readTrustFile = readTrustFile;
+const writeTrustFile = (path, file) => {
+    const { sealedOnce: _retired, ...kept } = file;
+    const temp = `${path}.${process.pid}.${(0, node_crypto_1.randomBytes)(6).toString('hex')}.tmp`;
+    // Synced before the rename: a crash leaves the old file or the new one, not an empty one that reads as unusable.
+    const fd = (0, node_fs_1.openSync)(temp, 'wx', 0o600);
+    try {
+        try {
+            (0, node_fs_1.writeSync)(fd, `${JSON.stringify({ ...kept, version: TRUST_VERSION }, null, 2)}\n`);
+            (0, node_fs_1.fsyncSync)(fd);
+        }
+        finally {
+            (0, node_fs_1.closeSync)(fd);
+        }
+        (0, node_fs_1.renameSync)(temp, path);
+    }
+    catch (err) {
+        (0, node_fs_1.rmSync)(temp, { force: true });
+        throw err;
+    }
+};
+const ageOf = (lock) => {
+    try {
+        return Date.now() - (0, node_fs_1.statSync)(lock).mtimeMs;
+    }
+    catch {
+        return null;
+    }
+};
+const sleepSync = (ms) => {
+    Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+};
+/**
+ * Run `fn` holding `trusted-devices.lock` beside the trust file, created with `wx` as the cli creates it. `locked: false`:
+ * the lock was held past `waitMs` or cannot be made, and `fn` did not run.
+ */
+const withTrustLock = (trustPath, fn, { waitMs = WAIT_MS } = {}) => {
+    const lock = `${trustPath.replace(/\.json$/, '')}.lock`;
+    const deadline = Date.now() + waitMs;
+    let brokeStale = false;
+    try {
+        (0, node_fs_1.mkdirSync)((0, node_path_1.dirname)(lock), { recursive: true, mode: 0o700 });
+    }
+    catch {
+        return { locked: false };
+    }
+    for (;;) {
+        try {
+            const fd = (0, node_fs_1.openSync)(lock, 'wx', 0o600);
+            try {
+                (0, node_fs_1.writeSync)(fd, `${process.pid} ${Date.now()}\n`);
+            }
+            catch {
+                // An empty lock nobody owns would hold every writer off until it goes stale.
+                (0, node_fs_1.rmSync)(lock, { force: true });
+                return { locked: false };
+            }
+            finally {
+                (0, node_fs_1.closeSync)(fd);
+            }
+            break;
+        }
+        catch (err) {
+            if (err.code !== 'EEXIST')
+                return { locked: false }; // err.code is how node names a lock that is there
+            // Looked at again right before the unlink: another waiter may have broken it and taken a fresh lock meanwhile.
+            const age = ageOf(lock);
+            if (!brokeStale && age !== null && age > STALE_MS && (ageOf(lock) ?? 0) > STALE_MS) {
+                brokeStale = true;
+                try {
+                    (0, node_fs_1.unlinkSync)(lock);
+                }
+                catch { /* someone else broke it first */ }
+                continue;
+            }
+            if (Date.now() >= deadline)
+                return { locked: false };
+            sleepSync(POLL_MS);
+        }
+    }
+    try {
+        return { locked: true, value: fn() };
+    }
+    finally {
+        (0, node_fs_1.rmSync)(lock, { force: true });
+    }
+};
+exports.withTrustLock = withTrustLock;
+/** An id is read from the file's own entries: `__proto__` or `constructor` passes `DEVICE_ID` and would read an inherited member. */
+const ownEntry = (record, id) => record !== undefined && Object.hasOwn(record, id) ? record[id] : undefined;
+/** One key is one device: a key pinned for another id is the same device under a stamp the relay picked. */
+const pinnedElsewhere = (file, deviceId, sender) => Object.entries(file.devices).some(([id, pin]) => id !== deviceId && (0, crypto_js_1.publicKeySender)(pin.publicKey) === sender);
+/** The listener's number for a device moves to its old key before the pin goes: a new id for that key must not start from zero. */
+const foldCommandNumber = (file, deviceId, oldKey) => {
+    const commands = file.commands;
+    const n = ownEntry(commands, deviceId);
+    const sender = (0, crypto_js_1.publicKeySender)(oldKey);
+    if (!isCommandNumber(n) || sender === null)
+        return;
+    const keys = typeof file.commandKeys === 'object' && file.commandKeys !== null && !Array.isArray(file.commandKeys)
+        ? file.commandKeys
+        : {};
+    const held = keys[sender];
+    file.commandKeys = { ...keys, [sender]: isCommandNumber(held) ? Math.max(held, n) : n };
+};
+const apply = (file, devices, selfId, at) => {
+    const changes = { pinned: [], replaced: [], skipped: [] };
+    for (const { deviceId, publicKey } of devices) {
+        if (!publicKey || deviceId === selfId || !exports.DEVICE_ID.test(deviceId))
+            continue;
+        const sender = (0, crypto_js_1.publicKeySender)(publicKey);
+        if (sender === null)
+            continue;
+        const pin = ownEntry(file.devices, deviceId);
+        if (pin && (0, crypto_js_1.samePublicKey)(pin.publicKey, publicKey))
+            continue;
+        const tooMany = !pin && Object.keys(file.devices).length >= exports.MAX_PINNED_DEVICES;
+        if (pinnedElsewhere(file, deviceId, sender) || tooMany) {
+            changes.skipped.push(deviceId);
+            continue;
+        }
+        if (pin)
+            foldCommandNumber(file, deviceId, pin.publicKey);
+        file.devices = { ...file.devices, [deviceId]: { publicKey, pinnedAt: at.toISOString() } };
+        (pin ? changes.replaced : changes.pinned).push(deviceId);
+    }
+    return changes;
+};
+const unchanged = (c) => c.pinned.length === 0 && c.replaced.length === 0;
+/** A trust line on stderr, as the server writes its other lines. */
+const warnOnStderr = (line) => console.error(`[hwip] ${line}`);
+/** Told the file is unreadable: it stays so for every send after, so each warner hears it once per process. */
+const toldUnreadable = new WeakSet();
+/**
+ * Pin what `devices` lists: a new device is pinned, a changed key replaces its pin with one warning. Never refuses and
+ * never throws — a file that cannot be read or written leaves the pins as they were and the send goes on.
+ */
+const observeDevices = (path, devices, { selfId, now = () => new Date(), warn = warnOnStderr } = {}) => {
+    const quick = (0, exports.readTrustFile)(path);
+    if (quick === null) {
+        if (!toldUnreadable.has(warn)) {
+            toldUnreadable.add(warn);
+            warn('trust: the trust file is unreadable — pins not checked');
+        }
+        return { pinned: [], replaced: [], skipped: [], status: 'unreadable' };
+    }
+    const at = now();
+    const first = apply(quick, devices, selfId, at);
+    // The usual send changes nothing: no lock, no write.
+    if (unchanged(first))
+        return { ...first, status: 'ok' };
+    const names = new Map(devices.map((d) => [d.deviceId, d.nickname]));
+    const changesOf = (replaced, when) => replaced.map((deviceId) => ({ deviceId, at: when.toISOString(), name: names.get(deviceId) }));
+    // Not written: the send goes on with the key the list holds, and a changed key is still said — on stderr, and by
+    // this process's next tool result, since no record will.
+    const notWritten = (status) => {
+        for (const deviceId of first.replaced)
+            warn(`trust: ${deviceId} changed its key — could not record the new pin`);
+        (0, key_changes_js_1.holdKeyChanges)(changesOf(first.replaced, at));
+        return { pinned: [], replaced: first.replaced, skipped: [], status };
+    };
+    try {
+        // Read again under the lock: the listener or another send may have pinned meanwhile.
+        const done = (0, exports.withTrustLock)(path, () => {
+            const latest = (0, exports.readTrustFile)(path);
+            if (latest === null)
+                return null;
+            const when = now();
+            const changes = apply(latest, devices, selfId, when);
+            if (unchanged(changes))
+                return changes;
+            writeTrustFile(path, latest);
+            // In the same section as the pin: a process that sees the new key as `same` next has nothing left to say it.
+            const keyChanges = changesOf(changes.replaced, when);
+            if (!(0, key_changes_js_1.recordKeyChanges)(path, keyChanges)) {
+                warn('trust: could not save that key change for later (key-changes.json) — the next tool result notes it');
+                (0, key_changes_js_1.holdKeyChanges)(keyChanges);
+            }
+            return changes;
+        });
+        if (!done.locked || done.value === null)
+            return notWritten(done.locked ? 'unreadable' : 'unlocked');
+        for (const deviceId of done.value.replaced)
+            warn(`trust: ${deviceId} changed its key — now pinned to the new one`);
+        return { ...done.value, status: 'ok' };
+    }
+    catch {
+        // A full disk, a folder that is not ours: the send does not depend on the pin.
+        return notWritten('unlocked');
+    }
+};
+exports.observeDevices = observeDevices;

package/dist/types.d.ts

@@ -0,0 +1,157 @@
+export interface ApiErrorBody {
+    error: {
+        code: string;
+        message: string;
+        status: number;
+    };
+}
+export interface PushResponse {
+    data: {
+        pushId: string;
+    };
+}
+export interface HookTriggerResponse {
+    data: {
+        pushId: string;
+        eventId: string;
+        /** Whether the native push was queued. Absent from the answer to a repeat the server had already taken. */
+        notified?: boolean;
+    };
+}
+export interface HookEventResponse {
+    data: {
+        eventId: string;
+        status: 'pending' | 'responded' | 'timed_out' | 'cancelled';
+        response?: {
+            actionId?: string;
+            value?: string;
+            /** Screenshots and files the user attached to the answer — plaintext,
+             *  since the hook route carries no key this end could decrypt with. */
+            files?: AttachedFile[];
+            /** Sent with the phone's "send and exit" button: the text is the user's
+             *  last instruction and ends sticky REMOTE (remote-state.ts). */
+            exitRemote?: boolean;
+            respondedDeviceId?: string;
+            /** The answer to a sealed question: an envelope only the asking computer opens (ask-seal.ts). */
+            sealed?: unknown;
+        };
+    };
+}
+export interface DeviceRecord {
+    deviceId: string;
+    nickname?: string;
+    type?: string;
+    model?: string;
+    isOnline?: boolean;
+    lastSeenAt?: string;
+    publicKey?: string;
+    /** Where the device's listener takes local transfers (ADR-0013), or absent. */
+    lan?: {
+        host: string;
+        port: number;
+    } | null;
+    /** The tmux agent sessions this device's listener reports (a subset of hwip `AgentSession`). */
+    agentSessions?: {
+        name: string;
+        project?: string;
+        label?: string | null;
+        /** The name the agent calls the session (what the app shows). */
+        providerSessionName?: string | null;
+        /** Set on a view-only subagent pane. */
+        parentName?: string;
+        /** What runs in the session: an agent kind (`claude`, `pi`, …) or `shell` for a `hwip sh` session. */
+        agentKind?: string;
+    }[];
+    /** User renames, keyed by tmux name — a sibling of `agentSessions` so a listener re-report keeps them. */
+    agentSessionAliases?: Record<string, string>;
+}
+export interface DevicesResponse {
+    data: DeviceRecord[];
+}
+export interface DeviceKeyResponse {
+    data: DeviceRecord;
+}
+export interface AgentSessionRenameResponse {
+    data: DeviceRecord;
+}
+export interface PushRecord {
+    pushId: string;
+    type: string;
+    title?: string;
+    body?: string;
+    url?: string;
+    priority?: string;
+    senderDeviceId?: string;
+    targetDeviceId?: string;
+    channelId?: string;
+    fileKey?: string;
+    fileName?: string;
+    fileSize?: number;
+    /** End-to-end encrypted: `body` is the sealed envelope, not text (hwip `server/SERVER-API.md` Push). */
+    isEncrypted?: boolean;
+    createdAt: string;
+}
+export interface PushListResponse {
+    data: PushRecord[];
+    pagination: {
+        cursor?: string;
+        hasMore: boolean;
+    };
+}
+export interface DismissResponse {
+    data: {
+        dismissed: boolean | number;
+        badge?: number;
+    };
+}
+export interface ChannelRecord {
+    channelId: string;
+    tag: string;
+    name: string;
+    description?: string;
+    ownerId: string;
+    subscriberCount: number;
+    isPublic: boolean;
+}
+export interface ChannelsResponse {
+    data: ChannelRecord[];
+}
+export interface UploadRequestResponse {
+    data: {
+        fileId: string;
+        fileKey: string;
+        uploadUrl: string;
+    };
+}
+export interface AttachedFile {
+    fileKey: string;
+    fileName: string;
+    fileSize: number;
+    fileType: string;
+    iv?: string;
+    /**
+     * E2E: the file AES key wrapped once per recipient device, keyed by
+     * `deviceId`. Each value is a JSON string `{ encryptedKey, keyIv }`.
+     * (The superseded account-wide `encryptedKey` field is not written here —
+     * nothing can unwrap it since key escrow was removed.)
+     */
+    deviceKeyMap?: Record<string, string>;
+}
+/**
+ * A file handed straight to one device over the LAN (ADR-0013): no bytes in
+ * S3, so no `fileKey`. The push record keeps the feed honest and tells that
+ * device's listener which landed transfer to claim.
+ */
+export interface LanDeliveredFile extends Omit<AttachedFile, 'fileKey'> {
+    lanDeliveredTo: string;
+    transferId: string;
+}
+export interface ToolError {
+    error: string;
+    message: string;
+    /** The ask this error is about — set when the question reached the phone. */
+    eventId?: string;
+    retryAfter?: number;
+    suggestion?: string;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/url-check.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Where the API key may be sent. The key travels in the `X-API-Key` header to
+ * `baseUrl` and in the query of the `wsUrl` socket, so both URLs decide who can
+ * read it. Same rules as the cli's `wsUrlProblem` (src/ws-url.ts)
+ * and `insecureUrlWarning` (src/insecure-url.ts) — keep them in step.
+ */
+/** Why `url` cannot be a socket URL, or null. Never quotes userinfo, query or fragment: the log may be shared. */
+export declare const wsUrlProblem: (url: unknown) => string | null;
+/** One line of warning for a URL that sends the key in the clear to a non-loopback host, else null. */
+export declare const insecureUrlWarning: (url: string) => string | null;
+//# sourceMappingURL=url-check.d.ts.map

package/dist/url-check.js

@@ -0,0 +1,57 @@
+"use strict";
+/**
+ * Where the API key may be sent. The key travels in the `X-API-Key` header to
+ * `baseUrl` and in the query of the `wsUrl` socket, so both URLs decide who can
+ * read it. Same rules as the cli's `wsUrlProblem` (src/ws-url.ts)
+ * and `insecureUrlWarning` (src/insecure-url.ts) — keep them in step.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.insecureUrlWarning = exports.wsUrlProblem = void 0;
+/** Why `url` cannot be a socket URL, or null. Never quotes userinfo, query or fragment: the log may be shared. */
+const wsUrlProblem = (url) => {
+    // Whatever the config file holds: a number or a list is not a URL either.
+    if (typeof url !== 'string')
+        return 'the WebSocket URL has to be a string, like "wss://ws.hwip.app"';
+    const shown = url.replace(/\/\/[^/@]*@/, '//').replace(/[?#].*$/, '');
+    let parsed;
+    try {
+        parsed = new URL(url);
+    }
+    catch {
+        return `the WebSocket URL "${shown}" is not a URL — it needs a scheme, like wss://${shown.replace(/^[a-z][a-z0-9+.-]*:\/*/i, '')}`;
+    }
+    if (parsed.protocol !== 'ws:' && parsed.protocol !== 'wss:') {
+        return `the WebSocket URL "${shown}" must start with ws:// or wss://`;
+    }
+    // `?apiKey=…` is appended to it: a space or a fragment would break the connection (or put the key in the fragment).
+    if (/\s/.test(url))
+        return `the WebSocket URL "${shown}" has a space in it`;
+    if (parsed.hash)
+        return `the WebSocket URL "${shown}" has a #fragment, which a socket URL cannot carry`;
+    return null;
+};
+exports.wsUrlProblem = wsUrlProblem;
+// `localhost.` (a trailing dot), the unspecified address and its IPv4-mapped loopback form are this machine too.
+const LOOPBACK = /^(localhost|.*\.localhost|127(\.\d{1,3}){3}|0\.0\.0\.0|\[::1?\]|\[::ffff:7f[0-9a-f]{2}:[0-9a-f]{1,4}\])$/i;
+/** Whether `hostname` (from `URL.hostname`) is this machine. */
+const isLoopbackHost = (hostname) => LOOPBACK.test(hostname.replace(/\.$/, ''));
+/** One line of warning for a URL that sends the key in the clear to a non-loopback host, else null. */
+const insecureUrlWarning = (url) => {
+    let parsed;
+    try {
+        parsed = new URL(url);
+    }
+    catch {
+        return null;
+    }
+    if (isLoopbackHost(parsed.hostname))
+        return null;
+    if (parsed.protocol === 'http:') {
+        return `[hwip] ${parsed.host} is reached over plain http:// — your API key travels in the clear. Use an https:// base URL.`;
+    }
+    if (parsed.protocol === 'ws:') {
+        return `[hwip] the WebSocket at ${parsed.host} is reached over plain ws:// — your API key travels in the clear. Use a wss:// URL.`;
+    }
+    return null;
+};
+exports.insecureUrlWarning = insecureUrlWarning;

package/dist/ws-wait.d.ts

@@ -0,0 +1,72 @@
+/**
+ * WebSocket fast path for hook-response waits (SPEC-AGENT-AWARENESS §S3).
+ *
+ * The server broadcasts `hook.responded` / `hook.cancelled` the moment
+ * the user answers. This module subscribes to that feed so a wait can
+ * wake instantly instead of sitting out its poll interval.
+ *
+ * Trust model: the WS message is a WAKE-UP SIGNAL ONLY. The poll loop
+ * remains the single source of truth — on wake it immediately re-reads
+ * the event over REST and acts on that. A spoofed/garbled/duplicated
+ * frame can therefore cost at most one extra GET, never a wrong answer.
+ * The same property makes degradation trivial: no WebSocket global
+ * (Node < 22), no wsUrl configured, or a dropped socket all just mean
+ * "nobody wakes us early" and the existing poll cadence carries on.
+ *
+ * Connection lifecycle: lazy connect on first subscribe, shared across
+ * concurrent waits, app-level ping every 25 s (API GW $default route
+ * answers 'pong'; native WebSocket has no protocol-ping API), closed
+ * 30 s after the last pending wait ends. A socket that drops while a wait is
+ * pending is opened again after 1 s, doubling to 30 s.
+ */
+export interface WsLike {
+    readyState: number;
+    send(data: string): void;
+    close(): void;
+    addEventListener(type: string, listener: (event: {
+        data?: unknown;
+    }) => void): void;
+}
+export type WsFactory = (url: string) => WsLike;
+export interface WaitSubscription {
+    /** Resolves when the server says this event settled (answer or cancel). */
+    settled: Promise<void>;
+    /** Live socket right now? Drives the caller's poll cadence. */
+    isConnected(): boolean;
+    dispose(): void;
+}
+export interface HookResponseWaiterOptions {
+    wsUrl?: string;
+    apiKey: string;
+    /** Test seam. Defaults to globalThis.WebSocket when present. */
+    factory?: WsFactory;
+}
+/**
+ * A start-up line when hwip_ask cannot be woken over the WebSocket, or null. Without it the
+ * fast path is off in silence and every answer waits for the next poll (`poll.ts`).
+ */
+export declare const wsFastPathNotice: (wsUrl: string | undefined, hasWebSocket?: boolean) => string | null;
+export declare class HookResponseWaiter {
+    private readonly wsUrl?;
+    private readonly apiKey;
+    private readonly factory?;
+    private sock;
+    private connected;
+    private readonly pending;
+    private pingTimer;
+    private idleTimer;
+    private reconnectTimer;
+    /** Reconnects since the socket was last open: the next one waits 2^n s, up to 30 s. */
+    private reconnects;
+    constructor(opts: HookResponseWaiterOptions);
+    /** False when the fast path can't exist — caller skips subscribe(). */
+    canWait(): boolean;
+    subscribe(eventId: string): WaitSubscription;
+    private ensureSocket;
+    private handleMessage;
+    /** A wait still pending gets its fast path back; the poll loop covers the gap. */
+    private scheduleReconnect;
+    private scheduleIdleClose;
+    private teardownSocket;
+}
+//# sourceMappingURL=ws-wait.d.ts.map