@chorus-aidlc/openclaw-plugin 0.1.0

package/src/event-router.ts

@@ -0,0 +1,228 @@
+import type { ChorusMcpClient } from "./mcp-client.js";
+import type { ChorusPluginConfig } from "./config.js";
+import type { SseNotificationEvent } from "./sse-listener.js";
+
+export interface ChorusEventRouterOptions {
+  mcpClient: ChorusMcpClient;
+  config: ChorusPluginConfig;
+  triggerAgent: (message: string, metadata?: Record<string, unknown>) => void;
+  logger: { info: (msg: string) => void; warn: (msg: string) => void; error: (msg: string) => void };
+}
+
+/**
+ * Notification detail returned from chorus_get_notifications.
+ * Only the fields we need for routing.
+ */
+interface NotificationDetail {
+  uuid: string;
+  projectUuid: string;
+  entityType: string;
+  entityUuid: string;
+  entityTitle: string;
+  action: string;
+  message: string;
+  actorType: string;
+  actorUuid: string;
+  actorName: string;
+}
+
+export class ChorusEventRouter {
+  private readonly mcpClient: ChorusMcpClient;
+  private readonly config: ChorusPluginConfig;
+  private readonly triggerAgent: ChorusEventRouterOptions["triggerAgent"];
+  private readonly logger: ChorusEventRouterOptions["logger"];
+  private readonly projectFilter: Set<string>;
+
+  constructor(opts: ChorusEventRouterOptions) {
+    this.mcpClient = opts.mcpClient;
+    this.config = opts.config;
+    this.triggerAgent = opts.triggerAgent;
+    this.logger = opts.logger;
+    this.projectFilter = new Set(opts.config.projectUuids);
+  }
+
+  /**
+   * Route an incoming SSE notification event to the appropriate handler.
+   * Never throws — all errors are caught and logged internally.
+   */
+  dispatch(event: SseNotificationEvent): void {
+    // Only handle new_notification events (ignore count_update, etc.)
+    if (event.type !== "new_notification") {
+      this.logger.info(`SSE event type "${event.type}" ignored`);
+      return;
+    }
+
+    if (!event.notificationUuid) {
+      this.logger.warn("new_notification event missing notificationUuid, skipping");
+      return;
+    }
+
+    // Fetch full notification details and route asynchronously
+    this.fetchAndRoute(event.notificationUuid).catch((err) => {
+      this.logger.error(`Failed to fetch/route notification ${event.notificationUuid}: ${err}`);
+    });
+  }
+
+  // ---------------------------------------------------------------------------
+  // Internal
+  // ---------------------------------------------------------------------------
+
+  private async fetchAndRoute(notificationUuid: string): Promise<void> {
+    // Fetch notification details via MCP — use autoMarkRead=false so we don't
+    // consume all unread notifications, and status=unread since we just received it
+    const result = await this.mcpClient.callTool("chorus_get_notifications", {
+      status: "unread",
+      limit: 50,
+      autoMarkRead: false,
+    }) as { notifications?: NotificationDetail[] } | null;
+
+    const notifications = result?.notifications;
+    if (!notifications || !Array.isArray(notifications)) {
+      this.logger.warn(`Could not fetch notifications list`);
+      return;
+    }
+
+    const notification = notifications.find((n) => n.uuid === notificationUuid);
+    if (!notification) {
+      this.logger.warn(`Notification ${notificationUuid} not found in unread list`);
+      return;
+    }
+
+    // Project filter: if projectUuids is configured, ignore events from other projects
+    if (this.projectFilter.size > 0 && !this.projectFilter.has(notification.projectUuid)) {
+      this.logger.info(
+        `Notification for project ${notification.projectUuid} filtered out`
+      );
+      return;
+    }
+
+    // Route based on action (which corresponds to notificationType)
+    try {
+      switch (notification.action) {
+        case "task_assigned":
+          await this.handleTaskAssigned(notification);
+          break;
+        case "mentioned":
+          this.handleMentioned(notification);
+          break;
+        case "elaboration_requested":
+          this.handleElaborationRequested(notification);
+          break;
+        case "elaboration_answered":
+          this.handleElaborationAnswered(notification);
+          break;
+        case "proposal_rejected":
+          this.handleProposalRejected(notification);
+          break;
+        case "proposal_approved":
+          this.handleProposalApproved(notification);
+          break;
+        case "idea_claimed":
+          this.handleIdeaClaimed(notification);
+          break;
+        default:
+          this.logger.info(`Unhandled notification action: "${notification.action}"`);
+          break;
+      }
+    } catch (err) {
+      this.logger.error(`Error handling ${notification.action} notification: ${err}`);
+    }
+  }
+
+  /**
+   * Build @mention guidance for agent messages.
+   * Instructs the agent to @mention the actor after completing work.
+   */
+  private buildMentionGuidance(n: NotificationDetail, entityType: string): string {
+    return (
+      `After completing your work, post a comment on this ${entityType} using chorus_add_comment with @mention:\n` +
+      `Use this exact mention format: @[${n.actorName}](${n.actorType}:${n.actorUuid})`
+    );
+  }
+
+  private async handleTaskAssigned(n: NotificationDetail): Promise<void> {
+    const mentionGuidance = this.buildMentionGuidance(n, "task");
+
+    if (this.config.autoStart) {
+      try {
+        await this.mcpClient.callTool("chorus_claim_task", { taskUuid: n.entityUuid });
+        this.logger.info(`Auto-claimed task ${n.entityUuid}`);
+      } catch (err) {
+        this.logger.warn(`Failed to auto-claim task ${n.entityUuid}: ${err}`);
+        // Still trigger agent even if claim fails — let the agent handle it
+      }
+
+      this.triggerAgent(
+        `[Chorus] Task assigned: ${n.entityTitle}. Task UUID: ${n.entityUuid}, Project UUID: ${n.projectUuid}. Use chorus_get_task to see details and begin work.\n${mentionGuidance}`,
+        { notificationUuid: n.uuid, action: "task_assigned", entityUuid: n.entityUuid, projectUuid: n.projectUuid }
+      );
+    } else {
+      this.triggerAgent(
+        `[Chorus] Task assigned: ${n.entityTitle}. Task UUID: ${n.entityUuid}, Project UUID: ${n.projectUuid}. Use chorus_get_task to review when ready.\n${mentionGuidance}`,
+        { notificationUuid: n.uuid, action: "task_assigned", entityUuid: n.entityUuid, projectUuid: n.projectUuid }
+      );
+    }
+  }
+
+  private handleMentioned(n: NotificationDetail): void {
+    this.triggerAgent(
+      `[Chorus] You were @mentioned in ${n.entityType} '${n.entityTitle}' (projectUuid: ${n.projectUuid}): ${n.message}`,
+      { notificationUuid: n.uuid, action: "mentioned", entityUuid: n.entityUuid, projectUuid: n.projectUuid }
+    );
+  }
+
+  private handleElaborationRequested(n: NotificationDetail): void {
+    this.triggerAgent(
+      `[Chorus] Elaboration requested for idea '${n.entityTitle}' (ideaUuid: ${n.entityUuid}, projectUuid: ${n.projectUuid}). Use chorus_get_elaboration to review questions.`,
+      { notificationUuid: n.uuid, action: "elaboration_requested", entityUuid: n.entityUuid, projectUuid: n.projectUuid }
+    );
+  }
+
+  private handleProposalRejected(n: NotificationDetail): void {
+    const mentionGuidance = this.buildMentionGuidance(n, "proposal");
+
+    this.triggerAgent(
+      `[Chorus] Proposal '${n.entityTitle}' was REJECTED (proposalUuid: ${n.entityUuid}, projectUuid: ${n.projectUuid}). Review note: "${n.message}". ` +
+      `Use chorus_get_proposal to review the proposal, then fix issues with chorus_update_task_draft / chorus_update_document_draft. ` +
+      `After fixing, call chorus_validate_proposal then chorus_submit_proposal to resubmit.\n` +
+      mentionGuidance,
+      { notificationUuid: n.uuid, action: "proposal_rejected", entityUuid: n.entityUuid, projectUuid: n.projectUuid }
+    );
+  }
+
+  private handleProposalApproved(n: NotificationDetail): void {
+    const mentionGuidance = this.buildMentionGuidance(n, "proposal");
+
+    this.triggerAgent(
+      `[Chorus] Proposal '${n.entityTitle}' was APPROVED (projectUuid: ${n.projectUuid})! Documents and tasks have been created. ` +
+      `Use chorus_get_available_tasks with projectUuid: "${n.projectUuid}" to see the new tasks ready for work.\n` +
+      mentionGuidance,
+      { notificationUuid: n.uuid, action: "proposal_approved", entityUuid: n.entityUuid, projectUuid: n.projectUuid }
+    );
+  }
+
+  private handleIdeaClaimed(n: NotificationDetail): void {
+    const mentionGuidance = this.buildMentionGuidance(n, "idea");
+
+    this.triggerAgent(
+      `[Chorus] Idea '${n.entityTitle}' has been assigned to you (ideaUuid: ${n.entityUuid}, projectUuid: ${n.projectUuid}). ` +
+      `Use chorus_get_idea to review the idea, then chorus_claim_idea to start elaboration.\n` +
+      mentionGuidance,
+      { notificationUuid: n.uuid, action: "idea_claimed", entityUuid: n.entityUuid, projectUuid: n.projectUuid }
+    );
+  }
+
+  private handleElaborationAnswered(n: NotificationDetail): void {
+    const mentionGuidance = this.buildMentionGuidance(n, "idea");
+
+    this.triggerAgent(
+      `[Chorus] Elaboration answers submitted for idea '${n.entityTitle}' (ideaUuid: ${n.entityUuid}, projectUuid: ${n.projectUuid}). ` +
+      `Review the answers with chorus_get_elaboration, then either:\n` +
+      `- Call chorus_validate_elaboration with empty issues [] to resolve and proceed to proposal creation\n` +
+      `- Call chorus_validate_elaboration with issues + followUpQuestions for another round\n\n` +
+      `After reviewing, @mention the answerer to ask if they have any further questions before you proceed.\n` +
+      mentionGuidance,
+      { notificationUuid: n.uuid, action: "elaboration_answered", entityUuid: n.entityUuid, projectUuid: n.projectUuid }
+    );
+  }
+}

package/src/index.ts

@@ -0,0 +1,132 @@
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+type OpenClawPluginApi = any;
+
+import { chorusConfigSchema, type ChorusPluginConfig } from "./config.js";
+import { ChorusMcpClient } from "./mcp-client.js";
+import { ChorusSseListener } from "./sse-listener.js";
+import { ChorusEventRouter } from "./event-router.js";
+import { registerPmTools } from "./tools/pm-tools.js";
+import { registerDevTools } from "./tools/dev-tools.js";
+import { registerCommonTools } from "./tools/common-tools.js";
+import { registerChorusCommands } from "./commands.js";
+
+/**
+ * Trigger the OpenClaw agent by posting a system event to the gateway's
+ * /hooks/wake endpoint. This enqueues the text into the agent's prompt
+ * and triggers an immediate heartbeat so the agent processes it right away.
+ */
+async function wakeAgent(
+  gatewayUrl: string,
+  hooksToken: string,
+  text: string,
+  logger: { info: (msg: string) => void; warn: (msg: string) => void },
+) {
+  try {
+    const res = await fetch(`${gatewayUrl}/hooks/wake`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${hooksToken}`,
+      },
+      body: JSON.stringify({ text, mode: "now" }),
+    });
+    if (!res.ok) {
+      logger.warn(`Wake agent failed: HTTP ${res.status}`);
+    } else {
+      logger.info(`Agent woken: ${text.slice(0, 80)}...`);
+    }
+  } catch (err) {
+    logger.warn(`Wake agent error: ${err}`);
+  }
+}
+
+const plugin = {
+  id: "@chorus-aidlc/openclaw-plugin",
+  name: "Chorus",
+  description:
+    "Chorus AI-DLC collaboration platform — SSE real-time events + MCP tool integration",
+  configSchema: chorusConfigSchema,
+
+  register(api: OpenClawPluginApi) {
+    const config = api.pluginConfig as ChorusPluginConfig;
+    const logger = api.logger;
+
+    // Resolve gateway URL and hooks token from OpenClaw config
+    const gatewayPort = api.config?.gateway?.port ?? 18789;
+    const gatewayUrl = `http://127.0.0.1:${gatewayPort}`;
+    const hooksToken = api.config?.hooks?.token ?? "";
+
+    logger.info(
+      `Chorus plugin initializing — ${config.chorusUrl} (${config.projectUuids.length || "all"} projects)`
+    );
+
+    // --- MCP Client ---
+    const mcpClient = new ChorusMcpClient({
+      chorusUrl: config.chorusUrl,
+      apiKey: config.apiKey,
+      logger,
+    });
+
+    // --- Event Router ---
+    const eventRouter = new ChorusEventRouter({
+      mcpClient,
+      config,
+      logger,
+      triggerAgent: (message: string, _metadata?: Record<string, unknown>) => {
+        // Use /hooks/wake to enqueue a system event + trigger immediate heartbeat
+        if (hooksToken) {
+          wakeAgent(gatewayUrl, hooksToken, message, logger);
+        } else {
+          logger.warn(
+            `[Chorus] Cannot wake agent — gateway.auth.token not configured. Event: ${message.slice(0, 100)}`
+          );
+        }
+      },
+    });
+
+    // --- SSE Listener (background service) ---
+    let sseListener: ChorusSseListener | null = null;
+
+    api.registerService({
+      id: "chorus-sse",
+      async start() {
+        sseListener = new ChorusSseListener({
+          chorusUrl: config.chorusUrl,
+          apiKey: config.apiKey,
+          logger,
+          onEvent: (event) => eventRouter.dispatch(event),
+          onReconnect: async () => {
+            // Back-fill missed notifications after reconnect
+            try {
+              const result = (await mcpClient.callTool("chorus_get_notifications", {
+                status: "unread",
+                autoMarkRead: false,
+              })) as { notifications?: Array<{ uuid: string }> } | null;
+              const count = result?.notifications?.length ?? 0;
+              if (count > 0) {
+                logger.info(`SSE reconnect: ${count} unread notifications to process`);
+              }
+            } catch (err) {
+              logger.warn(`Failed to back-fill notifications: ${err}`);
+            }
+          },
+        });
+        await sseListener.connect();
+      },
+      async stop() {
+        sseListener?.disconnect();
+        await mcpClient.disconnect();
+      },
+    });
+
+    // --- Tools ---
+    registerPmTools(api, mcpClient);
+    registerDevTools(api, mcpClient);
+    registerCommonTools(api, mcpClient);
+
+    // --- Commands ---
+    registerChorusCommands(api, mcpClient, () => sseListener?.status ?? "disconnected");
+  },
+};
+
+export default plugin;

package/src/mcp-client.ts

@@ -0,0 +1,141 @@
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+
+export type McpClientStatus = "disconnected" | "connecting" | "connected" | "reconnecting";
+
+export interface ChorusMcpClientOptions {
+  chorusUrl: string;
+  apiKey: string;
+  logger: { info: (msg: string) => void; warn: (msg: string) => void; error: (msg: string) => void };
+}
+
+/**
+ * Wraps @modelcontextprotocol/sdk Client with:
+ * - Lazy connection (connect on first callTool)
+ * - Auto-reconnect on session expiry (404)
+ * - Status tracking
+ * - Graceful disconnect
+ */
+export class ChorusMcpClient {
+  private client: Client | null = null;
+  private transport: StreamableHTTPClientTransport | null = null;
+  private _status: McpClientStatus = "disconnected";
+  private readonly opts: ChorusMcpClientOptions;
+
+  constructor(opts: ChorusMcpClientOptions) {
+    this.opts = opts;
+  }
+
+  get status(): McpClientStatus {
+    return this._status;
+  }
+
+  /** Establish MCP connection. Called lazily on first callTool. */
+  async connect(): Promise<void> {
+    if (this._status === "connected" && this.client) return;
+
+    this._status = "connecting";
+    try {
+      this.transport = new StreamableHTTPClientTransport(
+        new URL("/api/mcp", this.opts.chorusUrl),
+        {
+          requestInit: {
+            headers: {
+              Authorization: `Bearer ${this.opts.apiKey}`,
+            },
+          },
+        }
+      );
+
+      this.client = new Client({
+        name: "openclaw-chorus",
+        version: "0.1.0",
+      });
+
+      await this.client.connect(this.transport);
+      this._status = "connected";
+      this.opts.logger.info("MCP connection established");
+    } catch (err) {
+      this._status = "disconnected";
+      this.client = null;
+      this.transport = null;
+      throw err;
+    }
+  }
+
+  /**
+   * Call a Chorus MCP tool. Handles lazy connection and auto-reconnect.
+   * Returns parsed JSON from the first text content block.
+   */
+  async callTool(name: string, args: Record<string, unknown> = {}): Promise<unknown> {
+    // Lazy connect
+    if (!this.client || this._status !== "connected") {
+      await this.connect();
+    }
+
+    try {
+      return await this._doCallTool(name, args);
+    } catch (err: unknown) {
+      // Session expired (404) or connection lost — reconnect and retry once
+      if (this.isSessionExpiredError(err)) {
+        this.opts.logger.warn("MCP session expired, reconnecting...");
+        this._status = "reconnecting";
+        this.client = null;
+        this.transport = null;
+        await this.connect();
+        return await this._doCallTool(name, args);
+      }
+      throw err;
+    }
+  }
+
+  /** Graceful disconnect. */
+  async disconnect(): Promise<void> {
+    if (this.client) {
+      try {
+        await this.client.close();
+      } catch {
+        // Ignore close errors
+      }
+    }
+    this.client = null;
+    this.transport = null;
+    this._status = "disconnected";
+    this.opts.logger.info("MCP connection closed");
+  }
+
+  private async _doCallTool(name: string, args: Record<string, unknown>): Promise<unknown> {
+    if (!this.client) throw new Error("MCP client not connected");
+
+    const result = await this.client.callTool({ name, arguments: args });
+
+    if (result.isError) {
+      const errorText = (result.content as Array<{ type: string; text?: string }>)
+        .filter((c) => c.type === "text")
+        .map((c) => c.text)
+        .join("\n");
+      throw new Error(`Chorus MCP tool error (${name}): ${errorText}`);
+    }
+
+    // Parse first text content block as JSON
+    const textContent = (result.content as Array<{ type: string; text?: string }>).find(
+      (c) => c.type === "text"
+    );
+    if (!textContent?.text) return null;
+
+    try {
+      return JSON.parse(textContent.text);
+    } catch {
+      // Return raw text if not valid JSON
+      return textContent.text;
+    }
+  }
+
+  private isSessionExpiredError(err: unknown): boolean {
+    if (err instanceof Error) {
+      const msg = err.message.toLowerCase();
+      return msg.includes("404") || msg.includes("session") || msg.includes("not found");
+    }
+    return false;
+  }
+}

package/src/sse-listener.ts

@@ -0,0 +1,184 @@
+export type SseListenerStatus = "connected" | "disconnected" | "reconnecting";
+
+export interface SseNotificationEvent {
+  type: string; // "new_notification"
+  notificationUuid?: string;
+  notificationType?: string; // "task_assigned", "mentioned", etc.
+  unreadCount?: number;
+  [key: string]: unknown;
+}
+
+export interface ChorusSseListenerOptions {
+  chorusUrl: string;
+  apiKey: string;
+  onEvent: (event: SseNotificationEvent) => void;
+  onReconnect: () => Promise<void>;
+  logger: { info: (msg: string) => void; warn: (msg: string) => void; error: (msg: string) => void };
+}
+
+const INITIAL_DELAY_MS = 1_000;
+const MAX_DELAY_MS = 30_000;
+
+export class ChorusSseListener {
+  private readonly opts: ChorusSseListenerOptions;
+  private _status: SseListenerStatus = "disconnected";
+  private abortController: AbortController | null = null;
+  private reconnectTimer: ReturnType<typeof setTimeout> | null = null;
+  private reconnectDelay = INITIAL_DELAY_MS;
+
+  constructor(opts: ChorusSseListenerOptions) {
+    this.opts = opts;
+  }
+
+  get status(): SseListenerStatus {
+    return this._status;
+  }
+
+  /** Start the SSE connection. Resolves once the first bytes arrive (or rejects on immediate failure). */
+  async connect(): Promise<void> {
+    this.clearReconnectTimer();
+
+    const abortController = new AbortController();
+    this.abortController = abortController;
+
+    const url = `${this.opts.chorusUrl.replace(/\/$/, "")}/api/events/notifications`;
+
+    let response: Response;
+    try {
+      response = await fetch(url, {
+        headers: {
+          Authorization: `Bearer ${this.opts.apiKey}`,
+          Accept: "text/event-stream",
+        },
+        signal: abortController.signal,
+      });
+    } catch (err) {
+      if (abortController.signal.aborted) return; // intentional disconnect
+      this.opts.logger.error(`SSE connection failed: ${err}`);
+      this.scheduleReconnect();
+      return;
+    }
+
+    if (!response.ok) {
+      this.opts.logger.error(`SSE endpoint returned ${response.status}`);
+      this.scheduleReconnect();
+      return;
+    }
+
+    if (!response.body) {
+      this.opts.logger.error("SSE response has no body");
+      this.scheduleReconnect();
+      return;
+    }
+
+    // Connection succeeded — reset backoff
+    const isReconnect = this._status === "reconnecting";
+    this._status = "connected";
+    this.reconnectDelay = INITIAL_DELAY_MS;
+    this.opts.logger.info("[Chorus] SSE connection established");
+
+    if (isReconnect) {
+      // Fire onReconnect callback so the caller can back-fill missed notifications
+      try {
+        await this.opts.onReconnect();
+      } catch (err) {
+        this.opts.logger.warn(`onReconnect callback error: ${err}`);
+      }
+    }
+
+    // Read the stream
+    this.consumeStream(response.body, abortController.signal);
+  }
+
+  /** Gracefully close the SSE connection. */
+  disconnect(): void {
+    this.clearReconnectTimer();
+    if (this.abortController) {
+      this.abortController.abort();
+      this.abortController = null;
+    }
+    this._status = "disconnected";
+    this.opts.logger.info("SSE connection closed");
+  }
+
+  // ---------------------------------------------------------------------------
+  // Internal
+  // ---------------------------------------------------------------------------
+
+  private async consumeStream(body: ReadableStream<Uint8Array>, signal: AbortSignal): Promise<void> {
+    const decoder = new TextDecoder();
+    const reader = body.getReader();
+    let buffer = "";
+
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done || signal.aborted) break;
+
+        buffer += decoder.decode(value, { stream: true });
+
+        // SSE messages are delimited by double newlines
+        let boundary: number;
+        while ((boundary = buffer.indexOf("\n\n")) !== -1) {
+          const raw = buffer.slice(0, boundary);
+          buffer = buffer.slice(boundary + 2);
+          this.processMessage(raw);
+        }
+      }
+    } catch (err) {
+      if (signal.aborted) return; // intentional disconnect
+      this.opts.logger.warn(`SSE stream error: ${err}`);
+    } finally {
+      try {
+        reader.releaseLock();
+      } catch {
+        // already released
+      }
+    }
+
+    // Stream ended unexpectedly — reconnect unless we were intentionally disconnected
+    if (!signal.aborted) {
+      this.opts.logger.warn("SSE stream ended, scheduling reconnect");
+      this.scheduleReconnect();
+    }
+  }
+
+  private processMessage(raw: string): void {
+    for (const line of raw.split("\n")) {
+      // Comment lines (heartbeats) — ignore
+      if (line.startsWith(":")) continue;
+
+      // Data lines
+      if (line.startsWith("data: ")) {
+        const jsonStr = line.slice(6);
+        try {
+          const event: SseNotificationEvent = JSON.parse(jsonStr);
+          this.opts.onEvent(event);
+        } catch (err) {
+          this.opts.logger.warn(`SSE JSON parse error: ${err} — raw: ${jsonStr}`);
+        }
+      }
+    }
+  }
+
+  private scheduleReconnect(): void {
+    this.clearReconnectTimer();
+    this._status = "reconnecting";
+
+    this.opts.logger.info(`SSE reconnecting in ${this.reconnectDelay}ms`);
+    this.reconnectTimer = setTimeout(() => {
+      this.reconnectTimer = null;
+      this.connect();
+    }, this.reconnectDelay);
+
+    // Exponential backoff: 1s → 2s → 4s → 8s → 16s → 30s
+    this.reconnectDelay = Math.min(this.reconnectDelay * 2, MAX_DELAY_MS);
+  }
+
+  private clearReconnectTimer(): void {
+    if (this.reconnectTimer !== null) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+  }
+}