@zhihand/mcp 0.29.0 → 0.32.0

package/dist/core/sse.js

@@ -1,16 +1,13 @@
 import { getCommand } from "./command.js";
-import { dbg } from "../daemon/logger.js";
-// Per-commandId callback registry for SSE-based ACK
+import { log } from "./logger.js";
+// Per-commandId callback registry for SSE-based ACK (global — ids are globally unique)
 const ackCallbacks = new Map();
-// Active SSE connection state
-let sseAbortController = null;
-let sseConnected = false;
 export function handleSSEEvent(event) {
-    dbg(`[sse-cmd] Event: kind=${event.kind}, command=${event.command?.id ?? "-"}`);
+    log.debug(`[sse-cmd] Event: kind=${event.kind}, command=${event.command?.id ?? "-"}`);
     if (event.kind === "command.acked" && event.command) {
         const callback = ackCallbacks.get(event.command.id);
         if (callback) {
-            dbg(`[sse-cmd] ACK callback for ${event.command.id}, ack_status=${event.command.ack_status}, ack_result=${JSON.stringify(event.command.ack_result ?? null)}`);
+            log.debug(`[sse-cmd] ACK callback for ${event.command.id}, ack_status=${event.command.ack_status}, ack_result=${JSON.stringify(event.command.ack_result ?? null)}`);
             callback(event.command);
             ackCallbacks.delete(event.command.id);
         }
@@ -20,36 +17,59 @@ export function subscribeToCommandAck(commandId, callback) {
     ackCallbacks.set(commandId, callback);
     return () => { ackCallbacks.delete(commandId); };
 }
-/**
- * Connect to the SSE event stream for command ACKs.
- * Maintains a persistent connection that dispatches events to registered callbacks.
- * Reconnects automatically on connection loss.
- */
-export function connectSSE(config) {
-    if (sseAbortController)
-        return; // Already connected
-    sseAbortController = new AbortController();
-    const { signal } = sseAbortController;
-    const url = `${config.controlPlaneEndpoint}/v1/credentials/${encodeURIComponent(config.credentialId)}/events/stream?topic=commands`;
-    (async () => {
+export class UserEventStream {
+    userId;
+    controllerToken;
+    endpoint;
+    handlers;
+    abortController = null;
+    _connected = false;
+    constructor(userId, controllerToken, endpoint, handlers) {
+        this.userId = userId;
+        this.controllerToken = controllerToken;
+        this.endpoint = endpoint;
+        this.handlers = handlers;
+    }
+    get connected() {
+        return this._connected;
+    }
+    start() {
+        if (this.abortController)
+            return;
+        this.abortController = new AbortController();
+        this.runLoop(this.abortController.signal);
+    }
+    stop() {
+        this.abortController?.abort();
+        this.abortController = null;
+        this._connected = false;
+    }
+    async runLoop(signal) {
+        let backoffMs = 1000;
+        const BACKOFF_MAX = 30_000;
+        const topics = "commands,device_profile,device.online,device.offline,credential.added,credential.removed";
+        const url = `${this.endpoint}/v1/users/${encodeURIComponent(this.userId)}/events/stream?topic=${topics}`;
         while (!signal.aborted) {
             try {
                 const response = await fetch(url, {
                     headers: {
                         "Accept": "text/event-stream",
-                        "x-zhihand-controller-token": config.controllerToken,
+                        "Authorization": `Bearer ${this.controllerToken}`,
                     },
                     signal,
                 });
                 if (!response.ok) {
                     throw new Error(`SSE connect failed: ${response.status}`);
                 }
-                sseConnected = true;
+                this._connected = true;
+                this.handlers.onConnected();
+                backoffMs = 1000;
                 const reader = response.body?.getReader();
                 if (!reader)
                     throw new Error("No response body for SSE");
                 const decoder = new TextDecoder();
                 let buffer = "";
+                let eventData = "";
                 while (!signal.aborted) {
                     const { done, value } = await reader.read();
                     if (done)
@@ -57,18 +77,17 @@ export function connectSSE(config) {
                     buffer += decoder.decode(value, { stream: true });
                     const lines = buffer.split("\n");
                     buffer = lines.pop() ?? "";
-                    let eventData = "";
                     for (const line of lines) {
                         if (line.startsWith("data: ")) {
-                            eventData += line.slice(6);
+                            eventData += (eventData ? "\n" : "") + line.slice(6);
                         }
                         else if (line === "" && eventData) {
                             try {
-                                const event = JSON.parse(eventData);
-                                handleSSEEvent(event);
+                                const ev = JSON.parse(eventData);
+                                this.dispatchEvent(ev);
                             }
                             catch {
-                                // Malformed event, skip
+                                // malformed, skip
                             }
                             eventData = "";
                         }
@@ -78,37 +97,68 @@ export function connectSSE(config) {
             catch (err) {
                 if (signal.aborted)
                     break;
-                sseConnected = false;
-                // Backoff before reconnect
-                await new Promise((r) => setTimeout(r, 3000));
+                this._connected = false;
+                this.handlers.onDisconnected();
+                await new Promise((r) => setTimeout(r, backoffMs));
+                backoffMs = Math.min(backoffMs * 2, BACKOFF_MAX);
             }
         }
-        sseConnected = false;
-    })();
-}
-/**
- * Disconnect the SSE event stream.
- */
-export function disconnectSSE() {
-    sseAbortController?.abort();
-    sseAbortController = null;
-    sseConnected = false;
+        this._connected = false;
+        this.handlers.onDisconnected();
+    }
+    dispatchEvent(ev) {
+        // Always dispatch command ACKs globally
+        handleSSEEvent(ev);
+        switch (ev.kind) {
+            case "device.online":
+                this.handlers.onDeviceOnline(ev.credential_id);
+                break;
+            case "device.offline":
+                this.handlers.onDeviceOffline(ev.credential_id);
+                break;
+            case "device_profile.updated":
+                if (ev.device_profile) {
+                    this.handlers.onDeviceProfileUpdated(ev.credential_id, ev.device_profile);
+                }
+                break;
+            case "command.acked":
+                this.handlers.onCommandAcked(ev);
+                break;
+            case "credential.added":
+                // The credential.added event carries the new credential metadata
+                // in ev.credential (with credential_id, label, platform, etc.).
+                // Fall back to the root event if ev.credential is absent, since
+                // credential_id is always on the root SSEEvent.
+                this.handlers.onCredentialAdded(ev.credential ?? { credential_id: ev.credential_id });
+                break;
+            case "credential.removed":
+                this.handlers.onCredentialRemoved(ev.credential_id);
+                break;
+        }
+    }
 }
-/**
- * Whether the SSE stream is currently connected.
- */
-export function isSSEConnected() {
-    return sseConnected;
+export async function fetchUserCredentials(endpoint, userId, controllerToken, onlineFilter) {
+    let url = `${endpoint}/v1/users/${encodeURIComponent(userId)}/credentials`;
+    if (onlineFilter !== undefined) {
+        url += `?online=${onlineFilter}`;
+    }
+    const response = await fetch(url, {
+        headers: { "Authorization": `Bearer ${controllerToken}` },
+        signal: AbortSignal.timeout(10_000),
+    });
+    if (!response.ok) {
+        throw new Error(`Fetch credentials failed: ${response.status}`);
+    }
+    const data = (await response.json());
+    return data.items ?? [];
 }
 /**
- * Wait for command ACK via SSE push.
- * Falls back to polling if SSE is not active.
+ * Wait for command ACK via SSE push (which should already be connected by the
+ * registry). Falls back to polling.
  */
 export async function waitForCommandAck(config, options) {
     const timeoutMs = options.timeoutMs ?? 15_000;
-    dbg(`[sse-cmd] Waiting for ACK: commandId=${options.commandId}, timeout=${timeoutMs}ms`);
-    // Ensure SSE is connected for real-time ACKs
-    connectSSE(config);
+    log.debug(`[sse-cmd] Waiting for ACK: commandId=${options.commandId}, timeout=${timeoutMs}ms`);
     return new Promise((resolve, reject) => {
         let resolved = false;
         let pollInterval;
@@ -123,28 +173,38 @@ export async function waitForCommandAck(config, options) {
             cleanup();
             resolve({ acked: true, command: ackedCommand });
         });
-        // Also poll as fallback (SSE may not be connected yet or may be reconnecting)
-        pollInterval = setInterval(async () => {
+        // Delay polling startup by 2s so SSE push ACK normally wins in the
+        // registry-connected path. CLI (zhihand test) still resolves via polling
+        // after the initial delay. This avoids hammering the backend with 500ms
+        // HTTP polls for every command when SSE is healthy.
+        const POLL_START_DELAY_MS = 2000;
+        const POLL_INTERVAL_MS = 500;
+        const startPolling = setTimeout(() => {
             if (resolved)
                 return;
-            try {
-                const cmd = await getCommand(config, options.commandId);
-                if (cmd.acked_at) {
-                    resolved = true;
-                    cleanup();
-                    resolve({ acked: true, command: cmd });
+            pollInterval = setInterval(async () => {
+                if (resolved)
+                    return;
+                try {
+                    const cmd = await getCommand(config, options.commandId);
+                    if (cmd.acked_at) {
+                        resolved = true;
+                        cleanup();
+                        resolve({ acked: true, command: cmd });
+                    }
                 }
-            }
-            catch {
-                // Polling failure is non-fatal; SSE or next poll may succeed
-            }
-        }, 500);
+                catch {
+                    // non-fatal
+                }
+            }, POLL_INTERVAL_MS);
+        }, POLL_START_DELAY_MS);
         options.signal?.addEventListener("abort", () => {
             cleanup();
             reject(new Error("The operation was aborted"));
         }, { once: true });
         function cleanup() {
             clearTimeout(timeout);
+            clearTimeout(startPolling);
             unsubscribe();
             if (pollInterval)
                 clearInterval(pollInterval);

package/dist/core/ws.d.ts

@@ -0,0 +1,92 @@
+/**
+ * WebSocket transport — replaces SSE for all real-time event streams.
+ *
+ * Provides:
+ *   - ReconnectingWebSocket: shared base with exponential backoff + jitter,
+ *     protocol-level ping/pong watchdog, and Bearer auth via HTTP upgrade header.
+ *   - UserEventWebSocket: per-user stream for device registry events.
+ *   - Command ACK infrastructure (handleWSEvent, subscribeToCommandAck, waitForCommandAck).
+ *   - fetchUserCredentials: HTTP REST helper (unchanged from sse.ts).
+ */
+import type { ZhiHandRuntimeConfig } from "./config.ts";
+import type { QueuedCommandRecord, WaitForCommandAckResult } from "./command.ts";
+export interface ReconnectingWSOptions {
+    url: string;
+    headers?: Record<string, string>;
+    onOpen?: () => void;
+    onClose?: (code: number, reason: string) => void;
+    onMessage?: (data: unknown) => void;
+    onError?: (err: Error) => void;
+}
+export declare class ReconnectingWebSocket {
+    private opts;
+    private ws;
+    private backoffMs;
+    private aborted;
+    private watchdogTimer;
+    private reconnectTimer;
+    private hadOpen;
+    private consecutiveFailures;
+    private static readonly MAX_CONSECUTIVE_FAILURES;
+    constructor(opts: ReconnectingWSOptions);
+    start(): void;
+    stop(): void;
+    send(data: string): void;
+    get connected(): boolean;
+    private connect;
+    private scheduleReconnect;
+    private resetWatchdog;
+    private clearWatchdog;
+}
+export interface WSEvent {
+    id: string;
+    topic: string;
+    kind: string;
+    credential_id: string;
+    command?: QueuedCommandRecord;
+    device_profile?: Record<string, unknown>;
+    credential?: Record<string, unknown>;
+    sequence: number;
+}
+export declare function handleWSEvent(event: WSEvent): void;
+export declare function subscribeToCommandAck(commandId: string, callback: (cmd: QueuedCommandRecord) => void): () => void;
+export interface UserEventStreamHandlers {
+    onDeviceOnline: (credentialId: string) => void;
+    onDeviceOffline: (credentialId: string) => void;
+    onDeviceProfileUpdated: (credentialId: string, profile: Record<string, unknown>) => void;
+    onCommandAcked: (event: WSEvent) => void;
+    onCredentialAdded: (credential: Record<string, unknown>) => void;
+    onCredentialRemoved: (credentialId: string) => void;
+    onConnected: () => void;
+    onDisconnected: () => void;
+}
+export declare class UserEventWebSocket {
+    private handlers;
+    private rws;
+    private lastProcessedSeq;
+    constructor(userId: string, controllerToken: string, endpoint: string, handlers: UserEventStreamHandlers);
+    get connected(): boolean;
+    start(): void;
+    stop(): void;
+    private handleMessage;
+    private dispatchEvent;
+}
+export interface CredentialResponse {
+    credential_id: string;
+    label?: string;
+    platform?: string;
+    online?: boolean;
+    paired_at?: string;
+    last_seen_at?: string;
+    device_profile?: Record<string, unknown>;
+}
+export declare function fetchUserCredentials(endpoint: string, userId: string, controllerToken: string, onlineFilter?: boolean): Promise<CredentialResponse[]>;
+/**
+ * Wait for command ACK via WS push (which should already be connected by the
+ * registry). Falls back to polling.
+ */
+export declare function waitForCommandAck(config: ZhiHandRuntimeConfig, options: {
+    commandId: string;
+    timeoutMs?: number;
+    signal?: AbortSignal;
+}): Promise<WaitForCommandAckResult>;

package/dist/core/ws.js

@@ -0,0 +1,327 @@
+/**
+ * WebSocket transport — replaces SSE for all real-time event streams.
+ *
+ * Provides:
+ *   - ReconnectingWebSocket: shared base with exponential backoff + jitter,
+ *     protocol-level ping/pong watchdog, and Bearer auth via HTTP upgrade header.
+ *   - UserEventWebSocket: per-user stream for device registry events.
+ *   - Command ACK infrastructure (handleWSEvent, subscribeToCommandAck, waitForCommandAck).
+ *   - fetchUserCredentials: HTTP REST helper (unchanged from sse.ts).
+ */
+import WebSocket from "ws";
+import { getCommand } from "./command.js";
+import { log } from "./logger.js";
+// ── Shared reconnecting base ─────────────────────────────
+const BACKOFF_INITIAL_MS = 1000;
+const BACKOFF_MAX_MS = 30_000;
+const WATCHDOG_TIMEOUT_MS = 35_000; // slightly > server ping interval (expect ~30s)
+export class ReconnectingWebSocket {
+    opts;
+    ws = null;
+    backoffMs = BACKOFF_INITIAL_MS;
+    aborted = false;
+    watchdogTimer = null;
+    reconnectTimer = null;
+    hadOpen = false;
+    consecutiveFailures = 0;
+    static MAX_CONSECUTIVE_FAILURES = 10;
+    constructor(opts) {
+        this.opts = opts;
+    }
+    start() {
+        this.aborted = false;
+        this.connect();
+    }
+    stop() {
+        this.aborted = true;
+        this.clearWatchdog();
+        if (this.reconnectTimer) {
+            clearTimeout(this.reconnectTimer);
+            this.reconnectTimer = null;
+        }
+        if (this.ws) {
+            this.ws.removeAllListeners();
+            if (this.ws.readyState === WebSocket.OPEN || this.ws.readyState === WebSocket.CONNECTING) {
+                this.ws.close(4000, "client shutdown");
+            }
+            this.ws = null;
+        }
+    }
+    send(data) {
+        if (this.ws?.readyState === WebSocket.OPEN) {
+            this.ws.send(data);
+        }
+    }
+    get connected() {
+        return this.ws?.readyState === WebSocket.OPEN;
+    }
+    connect() {
+        if (this.aborted)
+            return;
+        try {
+            this.ws = new WebSocket(this.opts.url, {
+                headers: this.opts.headers,
+            });
+        }
+        catch (err) {
+            log.error(`[ws] Failed to create WebSocket: ${err.message}`);
+            this.scheduleReconnect();
+            return;
+        }
+        this.ws.on("open", () => {
+            this.hadOpen = true;
+            this.consecutiveFailures = 0;
+            this.backoffMs = BACKOFF_INITIAL_MS;
+            this.resetWatchdog();
+            this.opts.onOpen?.();
+        });
+        this.ws.on("message", (raw) => {
+            this.resetWatchdog();
+            try {
+                const data = JSON.parse(raw.toString());
+                this.opts.onMessage?.(data);
+            }
+            catch {
+                // malformed message — ignore
+            }
+        });
+        this.ws.on("ping", () => {
+            // Protocol-level ping from server — ws lib auto-sends pong.
+            // Reset watchdog on any activity.
+            this.resetWatchdog();
+        });
+        this.ws.on("close", (code, reason) => {
+            this.clearWatchdog();
+            const reasonStr = reason.toString();
+            // Detect HTTP upgrade rejection (401/403 → close 1006 without prior open)
+            if (!this.hadOpen) {
+                this.consecutiveFailures++;
+                if (this.consecutiveFailures >= ReconnectingWebSocket.MAX_CONSECUTIVE_FAILURES) {
+                    log.error(`[ws] ${this.consecutiveFailures} consecutive connection failures — stopping retries (likely auth rejection)`);
+                    this.opts.onClose?.(code, reasonStr);
+                    return; // Don't reconnect
+                }
+            }
+            this.hadOpen = false;
+            this.opts.onClose?.(code, reasonStr);
+            if (!this.aborted && code !== 4001) {
+                // Don't reconnect on explicit auth failure (4001)
+                this.scheduleReconnect();
+            }
+        });
+        this.ws.on("error", (err) => {
+            this.opts.onError?.(err);
+        });
+    }
+    scheduleReconnect() {
+        if (this.aborted)
+            return;
+        // Jitter: ±25% of current backoff
+        const jitter = this.backoffMs * 0.25 * (Math.random() * 2 - 1);
+        const delay = Math.round(this.backoffMs + jitter);
+        this.reconnectTimer = setTimeout(() => {
+            this.reconnectTimer = null;
+            this.backoffMs = Math.min(this.backoffMs * 2, BACKOFF_MAX_MS);
+            this.connect();
+        }, delay);
+    }
+    resetWatchdog() {
+        this.clearWatchdog();
+        this.watchdogTimer = setTimeout(() => {
+            log.warn("[ws] Watchdog timeout — no activity in 35s, reconnecting");
+            if (this.ws) {
+                this.ws.removeAllListeners();
+                this.ws.close(4000, "watchdog timeout");
+                this.ws = null;
+            }
+            this.opts.onClose?.(4000, "watchdog timeout");
+            this.scheduleReconnect();
+        }, WATCHDOG_TIMEOUT_MS);
+    }
+    clearWatchdog() {
+        if (this.watchdogTimer) {
+            clearTimeout(this.watchdogTimer);
+            this.watchdogTimer = null;
+        }
+    }
+}
+// ── Command ACK infrastructure (migrated from sse.ts) ────
+const ackCallbacks = new Map();
+export function handleWSEvent(event) {
+    log.debug(`[ws-cmd] Event: kind=${event.kind}, command=${event.command?.id ?? "-"}`);
+    if (event.kind === "command.acked" && event.command) {
+        const callback = ackCallbacks.get(event.command.id);
+        if (callback) {
+            log.debug(`[ws-cmd] ACK callback for ${event.command.id}, ack_status=${event.command.ack_status}, ack_result=${JSON.stringify(event.command.ack_result ?? null)}`);
+            callback(event.command);
+            ackCallbacks.delete(event.command.id);
+        }
+    }
+}
+export function subscribeToCommandAck(commandId, callback) {
+    ackCallbacks.set(commandId, callback);
+    return () => { ackCallbacks.delete(commandId); };
+}
+export class UserEventWebSocket {
+    handlers;
+    rws;
+    lastProcessedSeq = new Map();
+    constructor(userId, controllerToken, endpoint, handlers) {
+        this.handlers = handlers;
+        const topics = "commands,device_profile,device.online,device.offline,credential.added,credential.removed";
+        const wsUrl = `${endpoint.replace(/^http/, "ws")}/v1/users/${encodeURIComponent(userId)}/ws?topic=${topics}`;
+        this.rws = new ReconnectingWebSocket({
+            url: wsUrl,
+            headers: { "Authorization": `Bearer ${controllerToken}` },
+            onOpen: () => {
+                this.handlers.onConnected();
+            },
+            onClose: (_code, _reason) => {
+                this.handlers.onDisconnected();
+            },
+            onMessage: (data) => {
+                this.handleMessage(data);
+            },
+            onError: (err) => {
+                log.error(`[ws] UserEventWebSocket error: ${err.message}`);
+            },
+        });
+    }
+    get connected() {
+        return this.rws.connected;
+    }
+    start() {
+        this.rws.start();
+    }
+    stop() {
+        this.rws.stop();
+    }
+    handleMessage(data) {
+        const msg = data;
+        // Application-level ping (if server sends these alongside protocol pings)
+        if (msg.type === "ping") {
+            this.rws.send(JSON.stringify({ type: "pong" }));
+            return;
+        }
+        // Auth responses (if server uses message-based auth instead of/in addition to header auth)
+        if (msg.type === "auth_ok")
+            return;
+        if (msg.type === "auth_error") {
+            log.error(`[ws] Auth failed: ${msg.error}`);
+            this.rws.stop(); // Don't retry with invalid credentials
+            this.handlers.onDisconnected();
+            return;
+        }
+        // Event dispatch
+        if (msg.type === "event" || msg.kind) {
+            const ev = msg;
+            this.dispatchEvent(ev);
+        }
+    }
+    dispatchEvent(ev) {
+        // Sequence dedup per credential
+        if (ev.credential_id && ev.sequence != null) {
+            const lastSeq = this.lastProcessedSeq.get(ev.credential_id) ?? -1;
+            if (ev.sequence <= lastSeq)
+                return;
+            this.lastProcessedSeq.set(ev.credential_id, ev.sequence);
+        }
+        // Global command ACK dispatch
+        handleWSEvent(ev);
+        switch (ev.kind) {
+            case "device.online":
+                this.handlers.onDeviceOnline(ev.credential_id);
+                break;
+            case "device.offline":
+                this.handlers.onDeviceOffline(ev.credential_id);
+                break;
+            case "device_profile.updated":
+                if (ev.device_profile) {
+                    this.handlers.onDeviceProfileUpdated(ev.credential_id, ev.device_profile);
+                }
+                break;
+            case "command.acked":
+                this.handlers.onCommandAcked(ev);
+                break;
+            case "credential.added":
+                this.handlers.onCredentialAdded(ev.credential ?? { credential_id: ev.credential_id });
+                break;
+            case "credential.removed":
+                this.handlers.onCredentialRemoved(ev.credential_id);
+                break;
+        }
+    }
+}
+export async function fetchUserCredentials(endpoint, userId, controllerToken, onlineFilter) {
+    let url = `${endpoint}/v1/users/${encodeURIComponent(userId)}/credentials`;
+    if (onlineFilter !== undefined) {
+        url += `?online=${onlineFilter}`;
+    }
+    const response = await fetch(url, {
+        headers: { "Authorization": `Bearer ${controllerToken}` },
+        signal: AbortSignal.timeout(10_000),
+    });
+    if (!response.ok) {
+        throw new Error(`Fetch credentials failed: ${response.status}`);
+    }
+    const data = (await response.json());
+    return data.items ?? [];
+}
+/**
+ * Wait for command ACK via WS push (which should already be connected by the
+ * registry). Falls back to polling.
+ */
+export async function waitForCommandAck(config, options) {
+    const timeoutMs = options.timeoutMs ?? 15_000;
+    log.debug(`[ws-cmd] Waiting for ACK: commandId=${options.commandId}, timeout=${timeoutMs}ms`);
+    return new Promise((resolve, reject) => {
+        let resolved = false;
+        let pollInterval;
+        const timeout = setTimeout(() => {
+            cleanup();
+            resolve({ acked: false });
+        }, timeoutMs);
+        const unsubscribe = subscribeToCommandAck(options.commandId, (ackedCommand) => {
+            if (resolved)
+                return;
+            resolved = true;
+            cleanup();
+            resolve({ acked: true, command: ackedCommand });
+        });
+        // Delay polling startup by 2s so WS push ACK normally wins in the
+        // registry-connected path. CLI (zhihand test) still resolves via polling
+        // after the initial delay.
+        const POLL_START_DELAY_MS = 2000;
+        const POLL_INTERVAL_MS = 500;
+        const startPolling = setTimeout(() => {
+            if (resolved)
+                return;
+            pollInterval = setInterval(async () => {
+                if (resolved)
+                    return;
+                try {
+                    const cmd = await getCommand(config, options.commandId);
+                    if (cmd.acked_at) {
+                        resolved = true;
+                        cleanup();
+                        resolve({ acked: true, command: cmd });
+                    }
+                }
+                catch {
+                    // non-fatal
+                }
+            }, POLL_INTERVAL_MS);
+        }, POLL_START_DELAY_MS);
+        options.signal?.addEventListener("abort", () => {
+            cleanup();
+            reject(new Error("The operation was aborted"));
+        }, { once: true });
+        function cleanup() {
+            clearTimeout(timeout);
+            clearTimeout(startPolling);
+            unsubscribe();
+            if (pollInterval)
+                clearInterval(pollInterval);
+        }
+    });
+}