@zhihand/mcp 0.30.0 → 0.32.0

package/dist/core/sse.js

@@ -1,13 +1,13 @@
 import { getCommand } from "./command.js";
-import { dbg } from "../daemon/logger.js";
+import { log } from "./logger.js";
 // Per-commandId callback registry for SSE-based ACK (global — ids are globally unique)
 const ackCallbacks = new Map();
 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);
         }
@@ -17,30 +17,52 @@ export function subscribeToCommandAck(commandId, callback) {
     ackCallbacks.set(commandId, callback);
     return () => { ackCallbacks.delete(commandId); };
 }
-/**
- * Open a per-credential SSE connection. Caller owns the returned AbortController.
- * The loop auto-reconnects with exponential backoff until aborted.
- */
-export function connectSSEForCredential(config, handlers) {
-    const controller = new AbortController();
-    const { signal } = controller;
-    const url = `${config.controlPlaneEndpoint}/v1/credentials/${encodeURIComponent(config.credentialId)}/events/stream`;
-    let backoffMs = 1000;
-    const BACKOFF_MAX = 30_000;
-    (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}`);
                 }
-                handlers.onConnected();
+                this._connected = true;
+                this.handlers.onConnected();
                 backoffMs = 1000;
                 const reader = response.body?.getReader();
                 if (!reader)
@@ -62,7 +84,7 @@ export function connectSSEForCredential(config, handlers) {
                         else if (line === "" && eventData) {
                             try {
                                 const ev = JSON.parse(eventData);
-                                handlers.onEvent(ev);
+                                this.dispatchEvent(ev);
                             }
                             catch {
                                 // malformed, skip
@@ -75,14 +97,60 @@ export function connectSSEForCredential(config, handlers) {
             catch (err) {
                 if (signal.aborted)
                     break;
-                handlers.onDisconnected();
+                this._connected = false;
+                this.handlers.onDisconnected();
                 await new Promise((r) => setTimeout(r, backoffMs));
                 backoffMs = Math.min(backoffMs * 2, BACKOFF_MAX);
             }
         }
-        handlers.onDisconnected();
-    })();
-    return controller;
+        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;
+        }
+    }
+}
+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 (which should already be connected by the
@@ -90,7 +158,7 @@ export function connectSSEForCredential(config, handlers) {
  */
 export async function waitForCommandAck(config, options) {
     const timeoutMs = options.timeoutMs ?? 15_000;
-    dbg(`[sse-cmd] Waiting for ACK: commandId=${options.commandId}, timeout=${timeoutMs}ms`);
+    log.debug(`[sse-cmd] Waiting for ACK: commandId=${options.commandId}, timeout=${timeoutMs}ms`);
     return new Promise((resolve, reject) => {
         let resolved = false;
         let 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);
+        }
+    });
+}

package/dist/daemon/dispatcher.js

@@ -779,7 +779,7 @@ export async function postReply(config, promptId, text) {
             method: "POST",
             headers: {
                 "Content-Type": "application/json",
-                "x-zhihand-controller-token": config.controllerToken,
+                "Authorization": `Bearer ${config.controllerToken}`,
             },
             body: JSON.stringify({ role: "assistant", text }),
             signal: AbortSignal.timeout(30_000),

package/dist/daemon/heartbeat.js

@@ -25,7 +25,7 @@ async function sendHeartbeat(config, online) {
             method: "POST",
             headers: {
                 "Content-Type": "application/json",
-                "x-zhihand-controller-token": config.controllerToken,
+                "Authorization": `Bearer ${config.controllerToken}`,
             },
             body: JSON.stringify(body),
             signal: AbortSignal.timeout(10_000),

package/dist/daemon/index.js

@@ -14,7 +14,7 @@ import { setDebugEnabled, dbg } from "./logger.js";
 import { registry } from "../core/registry.js";
 const DEFAULT_PORT = 18686;
 const PID_FILE = "daemon.pid";
-// ── State ──────────────────────────────────────────────────
+// ── State ────────���─────────────────────────────────────────
 let activeBackend = null;
 let activeModel = null; // user-selected model alias, null = use default
 let isProcessing = false;
@@ -153,7 +153,7 @@ function readPid() {
 export function isAlreadyRunning() {
     return readPid();
 }
-// ── Main Daemon Entry ──────────────────────────────────────
+// ── Main Daemon Entry ──────���───────────────────────────────
 export async function startDaemon(options) {
     if (options?.debug)
         setDebugEnabled(true);
@@ -190,7 +190,7 @@ export async function startDaemon(options) {
     else {
         log(`[config] No backend configured. Use: zhihand gemini / zhihand claude / zhihand codex`);
     }
-    // Init the multi-device registry (single-device in daemon context) and log profile.
+    // Init the multi-device registry and log profile.
     await registry.init();
     const defaultState = registry.resolveDefault();
     if (defaultState?.profile) {

package/dist/daemon/prompt-listener.d.ts

@@ -16,19 +16,18 @@ export declare class PromptListener {
     private handler;
     private log;
     private processedIds;
-    private sseAbort;
+    private rws;
     private pollTimer;
-    private sseConnected;
+    private wsConnected;
     private stopped;
     constructor(config: ZhiHandConfig, handler: PromptHandler, log: (msg: string) => void);
     start(): void;
     stop(): void;
     private dispatchPrompt;
-    private connectSSE;
-    private resetWatchdog;
-    private handleSSEEvent;
+    private connectWS;
+    private handleWSMessage;
+    private handleEvent;
     private startPolling;
-    /** Recursive setTimeout: waits for fetch to complete before scheduling next poll. */
     private schedulePoll;
     private stopPolling;
     private poll;