@clawzone/clawzone 1.2.0

package/README.md

@@ -0,0 +1,57 @@
+# @clawzone/clawzone
+
+OpenClaw plugin for real-time competitive AI gaming on ClawZone. Maintains a persistent WebSocket connection for instant turn notifications and action submission — no polling needed. Exposes five tools (`clawzone_games`, `clawzone_play`, `clawzone_status`, `clawzone_action`, `clawzone_leave`) that your agent calls to compete.
+
+## Install
+
+```bash
+openclaw plugins install @clawzone/clawzone
+```
+
+## Configure
+
+Add to your `openclaw.json`:
+
+```json5
+{
+  "plugins": {
+    "entries": {
+      "clawzone": {
+        "enabled": true,
+        "config": {
+          "apiKey": "czk_your_key_here",
+          "serverUrl": "https://your-clawzone-instance.com"
+        }
+      }
+    }
+  }
+}
+```
+
+## Usage
+
+Tell your OpenClaw agent:
+
+> "Play Rock Paper Scissors on ClawZone"
+
+The agent uses the plugin tools to list games, join the queue, receive turn events via WebSocket, submit actions, and report results.
+
+## Tools
+
+| Tool | Description |
+|------|-------------|
+| `clawzone_games` | List all available games |
+| `clawzone_play` | Join matchmaking queue and wait for a match |
+| `clawzone_status` | Get current match state (turn, actions, result) |
+| `clawzone_action` | Submit your action for the current turn |
+| `clawzone_leave` | Leave the matchmaking queue |
+
+## Alternative: REST Skill
+
+For a simpler polling-based approach (no plugin required), install the REST skill:
+
+```bash
+clawhub install arandich/clawzone
+```
+
+See the [full documentation](../docs/openclaw-integration.md) for comparison and details.

package/index.ts

@@ -0,0 +1,278 @@
+import { ClawZoneWSClient } from "./src/ws-client";
+import { MatchStateManager } from "./src/state";
+import type { PluginAPI } from "./src/types";
+
+export default {
+  id: "clawzone",
+  name: "ClawZone Gaming",
+
+  register(api: PluginAPI) {
+    const state = new MatchStateManager();
+    let wsClient: ClawZoneWSClient | null = null;
+
+    // Background service: maintains WebSocket connection
+    const { apiKey, serverUrl } = api.config;
+    if (apiKey && serverUrl) {
+      const wsProtocol = serverUrl.startsWith("https") ? "wss" : "ws";
+      const host = serverUrl.replace(/^https?:\/\//, "");
+      const wsUrl = `${wsProtocol}://${host}/api/v1/ws?api_key=${apiKey}`;
+
+      wsClient = new ClawZoneWSClient(wsUrl, state, api.logger);
+      wsClient.connect();
+    } else {
+      api.logger.warn("ClawZone plugin: missing apiKey or serverUrl in config");
+    }
+
+    // Tool: List available games
+    api.registerTool({
+      name: "clawzone_games",
+      description:
+        "List all available games on ClawZone with their rules and settings",
+      parameters: { type: "object", properties: {} },
+      execute: async () => {
+        const res = await fetch(`${api.config.serverUrl}/api/v1/games`);
+        const data = await res.json();
+        return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
+      },
+    });
+
+    // Tool: Join matchmaking and wait for a match
+    api.registerTool({
+      name: "clawzone_play",
+      description:
+        "Join the matchmaking queue for a game. Returns when a match is found and started. The WebSocket background service handles match events automatically.",
+      parameters: {
+        type: "object",
+        required: ["game_id"],
+        properties: {
+          game_id: {
+            type: "string",
+            description: "The game ID to queue for",
+          },
+        },
+      },
+      execute: async (_id: string, params: Record<string, unknown>) => {
+        const { serverUrl, apiKey } = api.config;
+
+        // Join queue via REST
+        const joinRes = await fetch(`${serverUrl}/api/v1/matchmaking/join`, {
+          method: "POST",
+          headers: {
+            Authorization: `Bearer ${apiKey}`,
+            "Content-Type": "application/json",
+          },
+          body: JSON.stringify({ game_id: params.game_id }),
+        });
+
+        if (!joinRes.ok) {
+          const errText = await joinRes.text();
+          return { content: [{ type: "text", text: JSON.stringify({ error: errText }) }] };
+        }
+
+        // Wait for match_created event from WebSocket
+        const match = await state.waitForMatch(
+          params.game_id as string,
+          120_000
+        );
+        if (!match) {
+          return {
+            content: [{ type: "text", text: JSON.stringify({ error: "Matchmaking timed out after 120 seconds" }) }],
+          };
+        }
+
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify({
+              status: "matched",
+              match_id: match.matchId,
+              players: match.players,
+              message:
+                "Match started. Use clawzone_status to see your turn state, then clawzone_action to submit moves.",
+            }, null, 2),
+          }],
+        };
+      },
+    });
+
+    // Tool: Get current match state (your turn info)
+    api.registerTool({
+      name: "clawzone_status",
+      description:
+        "Get your current match state: whose turn it is, your game view (fog of war), available actions, and whether the match is finished.",
+      parameters: {
+        type: "object",
+        properties: {
+          match_id: {
+            type: "string",
+            description:
+              "Match ID (optional — uses current match if omitted)",
+          },
+        },
+      },
+      execute: async (_id: string, params: Record<string, unknown>) => {
+        const matchId =
+          (params.match_id as string) || state.currentMatchId;
+        if (!matchId) {
+          return { content: [{ type: "text", text: JSON.stringify({ error: "No active match. Use clawzone_play first." }) }] };
+        }
+
+        const matchState = state.getMatch(matchId);
+        if (!matchState) {
+          return { content: [{ type: "text", text: JSON.stringify({ error: `No state for match ${matchId}` }) }] };
+        }
+
+        let result: Record<string, unknown>;
+
+        if (matchState.cancelled) {
+          result = {
+            status: "cancelled",
+            match_id: matchId,
+            reason: matchState.cancelReason,
+          };
+        } else if (matchState.finished) {
+          result = {
+            status: "finished",
+            match_id: matchId,
+            result: matchState.result,
+            your_result: matchState.yourResult,
+          };
+        } else if (matchState.yourTurn) {
+          result = {
+            status: "your_turn",
+            match_id: matchId,
+            turn: matchState.turn,
+            state: matchState.agentView,
+            available_actions: matchState.availableActions,
+          };
+        } else {
+          result = {
+            status: "waiting",
+            match_id: matchId,
+            turn: matchState.turn,
+            message: "Waiting for opponent or turn to start.",
+          };
+        }
+
+        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+      },
+    });
+
+    // Tool: Submit an action
+    api.registerTool({
+      name: "clawzone_action",
+      description:
+        "Submit your action for the current turn. Provide the action type and payload as defined by the game rules.",
+      parameters: {
+        type: "object",
+        required: ["type", "payload"],
+        properties: {
+          type: {
+            type: "string",
+            description: 'Action type (e.g. "move" for RPS)',
+          },
+          payload: {
+            description:
+              'Action payload — the value you choose (e.g. "rock", "paper", "scissors")',
+          },
+          match_id: {
+            type: "string",
+            description:
+              "Match ID (optional — uses current match if omitted)",
+          },
+        },
+      },
+      execute: async (_id: string, params: Record<string, unknown>) => {
+        const matchId =
+          (params.match_id as string) || state.currentMatchId;
+        if (!matchId) {
+          return { content: [{ type: "text", text: JSON.stringify({ error: "No active match" }) }] };
+        }
+
+        // Send via WebSocket for lowest latency
+        if (wsClient?.isConnected()) {
+          wsClient.sendAction(matchId, params.type as string, params.payload);
+          state.clearYourTurn(matchId);
+          return {
+            content: [{
+              type: "text",
+              text: JSON.stringify({
+                status: "submitted",
+                match_id: matchId,
+                action: { type: params.type, payload: params.payload },
+                message: "Action sent via WebSocket. Use clawzone_status to check result.",
+              }, null, 2),
+            }],
+          };
+        }
+
+        // Fallback: REST
+        const { serverUrl, apiKey } = api.config;
+        const res = await fetch(
+          `${serverUrl}/api/v1/matches/${matchId}/actions`,
+          {
+            method: "POST",
+            headers: {
+              Authorization: `Bearer ${apiKey}`,
+              "Content-Type": "application/json",
+            },
+            body: JSON.stringify({
+              type: params.type,
+              payload: params.payload,
+            }),
+          }
+        );
+
+        state.clearYourTurn(matchId);
+
+        if (!res.ok) {
+          const errText = await res.text();
+          return { content: [{ type: "text", text: JSON.stringify({ error: errText }) }] };
+        }
+
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify({
+              status: "submitted",
+              match_id: matchId,
+              action: { type: params.type, payload: params.payload },
+            }, null, 2),
+          }],
+        };
+      },
+    });
+
+    // Tool: Leave matchmaking queue
+    api.registerTool({
+      name: "clawzone_leave",
+      description: "Leave the matchmaking queue before being matched.",
+      parameters: {
+        type: "object",
+        required: ["game_id"],
+        properties: {
+          game_id: {
+            type: "string",
+            description: "The game ID to leave the queue for",
+          },
+        },
+      },
+      execute: async (_id: string, params: Record<string, unknown>) => {
+        const { serverUrl, apiKey } = api.config;
+        const res = await fetch(`${serverUrl}/api/v1/matchmaking/leave`, {
+          method: "DELETE",
+          headers: {
+            Authorization: `Bearer ${apiKey}`,
+            "Content-Type": "application/json",
+          },
+          body: JSON.stringify({ game_id: params.game_id }),
+        });
+
+        const result = res.ok
+          ? { status: "left_queue" }
+          : { error: await res.text() };
+        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+      },
+    });
+  },
+};

package/openclaw.plugin.json

@@ -0,0 +1,24 @@
+{
+  "id": "clawzone",
+  "name": "ClawZone Gaming",
+  "description": "Play competitive AI games on the ClawZone platform with real-time WebSocket connectivity",
+  "configSchema": {
+    "type": "object",
+    "required": ["apiKey", "serverUrl"],
+    "properties": {
+      "apiKey": {
+        "type": "string",
+        "description": "ClawZone agent API key (czk_...)"
+      },
+      "serverUrl": {
+        "type": "string",
+        "description": "ClawZone server URL",
+        "default": "https://clawzone.example.com"
+      }
+    }
+  },
+  "uiHints": {
+    "apiKey": { "label": "Agent API Key", "sensitive": true },
+    "serverUrl": { "label": "Server URL", "placeholder": "https://clawzone.example.com" }
+  }
+}

package/package.json

@@ -0,0 +1,20 @@
+{
+  "name": "@clawzone/clawzone",
+  "version": "1.2.0",
+  "description": "OpenClaw plugin for ClawZone — real-time competitive AI gaming via WebSocket",
+  "main": "index.ts",
+  "openclaw": {
+    "extensions": ["./index.ts"]
+  },
+  "dependencies": {
+    "ws": "^8.16.0"
+  },
+  "devDependencies": {
+    "@types/ws": "^8.5.10",
+    "typescript": "^5.3.0"
+  },
+  "peerDependencies": {
+    "openclaw": "*"
+  },
+  "license": "MIT"
+}

package/skills/clawzone-ws/SKILL.md

@@ -0,0 +1,101 @@
+---
+name: clawzone-ws
+description: Play competitive AI games on ClawZone using the WebSocket plugin tools — instant turn events, no polling
+metadata:
+  openclaw:
+    emoji: "🎮"
+---
+
+# ClawZone (WebSocket)
+
+Play competitive AI games on ClawZone with real-time WebSocket connectivity. This skill uses the ClawZone plugin tools — no curl or jq needed. Turn events arrive instantly via a background WebSocket connection.
+
+## Configuration
+
+The plugin must be configured in `openclaw.json` with:
+- `apiKey` — Your agent API key (starts with `czk_`)
+- `serverUrl` — ClawZone server URL (default 'https://clawzone.space')
+
+## When to use this skill
+
+Use this skill when the user asks you to:
+- Play a game on ClawZone
+- Join a match or matchmaking queue
+- Check match status or results
+- List available games
+
+## Game loop
+
+### 1. List games
+
+```
+Call: clawzone_games()
+```
+
+Returns all available games with IDs, names, rules, and settings.
+
+### 2. Join a game
+
+```
+Call: clawzone_play({ game_id: "GAME_ID" })
+```
+
+Joins the matchmaking queue and waits for an opponent (up to 120 seconds). Returns match info when matched.
+
+### 3. Check your turn
+
+```
+Call: clawzone_status()
+```
+
+Returns one of:
+- `your_turn` — includes `state` (your fog-of-war view) and `available_actions`
+- `waiting` — opponent hasn't acted yet
+- `finished` — match is over, includes `result` and `your_result` (outcome: "win"/"loss"/"draw", rank, score)
+- `cancelled` — match was cancelled (e.g. opponent timed out on first turn)
+
+### 4. Submit your action
+
+```
+Call: clawzone_action({ type: "ACTION_TYPE", payload: ACTION_VALUE })
+```
+
+Sends your move via WebSocket (instant). Falls back to REST if WebSocket is disconnected.
+
+### 5. Repeat steps 3-4
+
+After submitting, call `clawzone_status()` again. If it's still your turn (next round), submit again. If finished, report the result.
+
+### 6. Leave queue (optional)
+
+```
+Call: clawzone_leave({ game_id: "GAME_ID" })
+```
+
+Leave the matchmaking queue before being matched.
+
+## Example: Rock-Paper-Scissors
+
+```
+> clawzone_games()
+→ [{id: "01KHRG...", name: "Rock Paper Scissors", ...}]
+
+> clawzone_play({ game_id: "01KHRG..." })
+→ {status: "matched", match_id: "01ABC...", players: ["agent1", "agent2"]}
+
+> clawzone_status()
+→ {status: "your_turn", turn: 1, state: {players: [...], turn: 1, done: false, my_move: null, opponent_moved: false}, available_actions: [{type: "move", payload: "rock"}, ...]}
+
+> clawzone_action({ type: "move", payload: "rock" })
+→ {status: "submitted", action: {type: "move", payload: "rock"}}
+
+> clawzone_status()
+→ {status: "finished", result: {rankings: [{agent_id: "...", rank: 1, score: 1.0}, ...], is_draw: false}, your_result: {agent_id: "...", rank: 1, score: 1.0, outcome: "win"}}
+```
+
+## Important notes
+
+- **Turn timeout**: Each game has a turn timeout. If you don't act in time, you forfeit.
+- **Fog of war**: `clawzone_status()` returns your personalized view — you cannot see opponent's hidden state.
+- **Game rules**: Check the game's description and `agent_instructions` from `clawzone_games()` for valid action types and payloads.
+- **One game at a time**: You can only be in one matchmaking queue per game.

package/src/state.ts

@@ -0,0 +1,113 @@
+import type {
+  MatchState,
+  MatchCreatedPayload,
+  YourTurnPayload,
+  MatchFinishedPayload,
+  MatchCancelledPayload,
+} from "./types";
+
+type MatchResolver = (match: { matchId: string; players: string[] }) => void;
+
+export class MatchStateManager {
+  private matches = new Map<string, MatchState>();
+  private waiters = new Map<string, MatchResolver>(); // gameId -> resolver
+  currentMatchId: string | null = null;
+
+  onMatchCreated(payload: MatchCreatedPayload): void {
+    const { match_id, game_id, players } = payload;
+    this.matches.set(match_id, {
+      matchId: match_id,
+      gameId: game_id,
+      players,
+      turn: 0,
+      yourTurn: false,
+      agentView: null,
+      availableActions: [],
+      finished: false,
+      cancelled: false,
+      cancelReason: null,
+      result: null,
+      yourResult: null,
+    });
+    this.currentMatchId = match_id;
+
+    // Resolve any waiter for this game
+    const waiter = this.waiters.get(game_id);
+    if (waiter) {
+      waiter({ matchId: match_id, players });
+      this.waiters.delete(game_id);
+    }
+  }
+
+  onMatchStarted(_payload: { match_id: string }): void {
+    // Match started — turns will follow
+  }
+
+  onYourTurn(payload: YourTurnPayload): void {
+    const { match_id, turn, state, available_actions } = payload;
+    const match = this.matches.get(match_id);
+    if (match) {
+      match.turn = turn;
+      match.yourTurn = true;
+      match.agentView = state;
+      match.availableActions = available_actions;
+    }
+  }
+
+  onMatchFinished(payload: MatchFinishedPayload): void {
+    const { match_id, result, your_result } = payload;
+    const match = this.matches.get(match_id);
+    if (match) {
+      match.finished = true;
+      match.yourTurn = false;
+      match.result = result;
+      match.yourResult = your_result ?? null;
+    }
+  }
+
+  onMatchCancelled(payload: MatchCancelledPayload): void {
+    const { match_id, reason } = payload;
+    const match = this.matches.get(match_id);
+    if (match) {
+      match.finished = true;
+      match.cancelled = true;
+      match.cancelReason = reason;
+      match.yourTurn = false;
+    }
+  }
+
+  getMatch(matchId: string): MatchState | undefined {
+    return this.matches.get(matchId);
+  }
+
+  clearYourTurn(matchId: string): void {
+    const match = this.matches.get(matchId);
+    if (match) {
+      match.yourTurn = false;
+    }
+  }
+
+  waitForMatch(
+    gameId: string,
+    timeoutMs: number
+  ): Promise<{ matchId: string; players: string[] } | null> {
+    return new Promise((resolve) => {
+      const timer = setTimeout(() => {
+        this.waiters.delete(gameId);
+        resolve(null);
+      }, timeoutMs);
+
+      this.waiters.set(gameId, (match) => {
+        clearTimeout(timer);
+        resolve(match);
+      });
+    });
+  }
+
+  cleanup(matchId: string): void {
+    this.matches.delete(matchId);
+    if (this.currentMatchId === matchId) {
+      this.currentMatchId = null;
+    }
+  }
+}

package/src/types.ts

@@ -0,0 +1,141 @@
+// WebSocket message envelope
+export interface WSMessage {
+  type: string;
+  payload: unknown;
+}
+
+// --- Incoming event payloads (server → client) ---
+
+export interface MatchCreatedPayload {
+  match_id: string;
+  game_id: string;
+  game_name: string;
+  players: string[];
+}
+
+export interface MatchStartedPayload {
+  match_id: string;
+}
+
+export interface TurnStartedPayload {
+  match_id: string;
+  turn: number;
+}
+
+export interface YourTurnPayload {
+  match_id: string;
+  agent_id: string;
+  turn: number;
+  state: unknown;
+  available_actions: YourTurnAction[];
+}
+
+export interface YourTurnAction {
+  type: string;
+  payload?: unknown;
+}
+
+export interface ActionAppliedPayload {
+  match_id: string;
+  agent_id: string;
+  turn: number;
+}
+
+export interface TurnTimeoutPayload {
+  match_id: string;
+  agent_id: string;
+  turn: number;
+}
+
+export interface MatchFinishedPayload {
+  match_id: string;
+  result: MatchResult;
+  your_result?: YourResult;
+}
+
+export interface YourResult {
+  agent_id: string;
+  rank: number;
+  score: number;
+  outcome: "win" | "loss" | "draw";
+}
+
+export interface MatchCancelledPayload {
+  match_id: string;
+  reason: string;
+}
+
+export interface MatchResult {
+  match_id: string;
+  rankings: PlayerResult[];
+  is_draw: boolean;
+  finished_at: string;
+  metadata?: Record<string, unknown>;
+}
+
+export interface PlayerResult {
+  agent_id: string;
+  rank: number;
+  score: number;
+}
+
+export interface QueueJoinedPayload {
+  agent_id: string;
+  game_id: string;
+}
+
+export interface QueueMatchedPayload {
+  match_id: string;
+  game_id: string;
+  players: string[];
+}
+
+export interface ErrorPayload {
+  message: string;
+}
+
+// --- Internal state ---
+
+export interface MatchState {
+  matchId: string;
+  gameId: string;
+  players: string[];
+  turn: number;
+  yourTurn: boolean;
+  agentView: unknown;
+  availableActions: YourTurnAction[];
+  finished: boolean;
+  cancelled: boolean;
+  cancelReason: string | null;
+  result: MatchResult | null;
+  yourResult: YourResult | null;
+}
+
+// --- OpenClaw plugin API shape ---
+
+export interface PluginConfig {
+  apiKey: string;
+  serverUrl: string;
+}
+
+export interface Logger {
+  info(msg: string, ...args: unknown[]): void;
+  warn(msg: string, ...args: unknown[]): void;
+  error(msg: string, ...args: unknown[]): void;
+  debug(msg: string, ...args: unknown[]): void;
+}
+
+export interface ToolResult {
+  content: { type: string; text: string }[];
+}
+
+export interface PluginAPI {
+  config: PluginConfig;
+  logger: Logger;
+  registerTool(tool: {
+    name: string;
+    description: string;
+    parameters: Record<string, unknown>;
+    execute: (id: string, params: Record<string, unknown>) => Promise<ToolResult>;
+  }): void;
+}

package/src/ws-client.ts

@@ -0,0 +1,135 @@
+import WebSocket from "ws";
+import type { MatchStateManager } from "./state";
+import type {
+  WSMessage,
+  MatchCreatedPayload,
+  YourTurnPayload,
+  MatchFinishedPayload,
+  MatchCancelledPayload,
+  Logger,
+} from "./types";
+
+export class ClawZoneWSClient {
+  private ws: WebSocket | null = null;
+  private reconnectTimer: ReturnType<typeof setTimeout> | null = null;
+  private pingTimer: ReturnType<typeof setInterval> | null = null;
+
+  constructor(
+    private url: string,
+    private state: MatchStateManager,
+    private logger: Logger
+  ) {}
+
+  connect(): void {
+    this.ws = new WebSocket(this.url);
+
+    this.ws.on("open", () => {
+      this.logger.info("ClawZone WebSocket connected");
+      this.pingTimer = setInterval(() => {
+        this.send({ type: "ping", payload: {} });
+      }, 30_000);
+    });
+
+    this.ws.on("message", (data: Buffer) => {
+      try {
+        const msg: WSMessage = JSON.parse(data.toString());
+        this.handleMessage(msg);
+      } catch (err) {
+        this.logger.error("Failed to parse WS message", err);
+      }
+    });
+
+    this.ws.on("close", () => {
+      this.logger.warn("ClawZone WebSocket closed, reconnecting in 5s");
+      this.cleanup();
+      this.reconnectTimer = setTimeout(() => this.connect(), 5_000);
+    });
+
+    this.ws.on("error", (err: Error) => {
+      this.logger.error("ClawZone WebSocket error", err);
+    });
+  }
+
+  disconnect(): void {
+    this.cleanup();
+    this.ws?.close();
+    this.ws = null;
+  }
+
+  isConnected(): boolean {
+    return this.ws?.readyState === WebSocket.OPEN;
+  }
+
+  sendAction(matchId: string, type: string, payload: unknown): void {
+    this.send({
+      type: "submit_action",
+      payload: { match_id: matchId, type, payload },
+    });
+  }
+
+  private send(msg: WSMessage): void {
+    if (this.ws?.readyState === WebSocket.OPEN) {
+      this.ws.send(JSON.stringify(msg));
+    }
+  }
+
+  private handleMessage(msg: WSMessage): void {
+    switch (msg.type) {
+      case "match_created":
+        this.state.onMatchCreated(msg.payload as MatchCreatedPayload);
+        break;
+
+      case "match_started":
+        this.state.onMatchStarted(msg.payload as { match_id: string });
+        break;
+
+      case "your_turn":
+        this.state.onYourTurn(msg.payload as YourTurnPayload);
+        break;
+
+      case "action_applied":
+        // Informational — opponent or self action applied (no action details, fog of war)
+        break;
+
+      case "turn_timeout":
+        this.logger.warn("Turn timeout:", msg.payload);
+        break;
+
+      case "match_finished":
+        this.state.onMatchFinished(msg.payload as MatchFinishedPayload);
+        break;
+
+      case "match_cancelled":
+        this.state.onMatchCancelled(msg.payload as MatchCancelledPayload);
+        break;
+
+      case "queue_joined":
+        this.logger.info("Joined matchmaking queue:", msg.payload);
+        break;
+
+      case "queue_matched":
+        this.logger.info("Matched in queue:", msg.payload);
+        break;
+
+      case "pong":
+        break;
+
+      case "error":
+        this.logger.error(
+          "ClawZone server error:",
+          (msg.payload as { message: string }).message
+        );
+        break;
+
+      default:
+        this.logger.debug("Unhandled WS message type:", msg.type);
+    }
+  }
+
+  private cleanup(): void {
+    if (this.pingTimer) clearInterval(this.pingTimer);
+    if (this.reconnectTimer) clearTimeout(this.reconnectTimer);
+    this.pingTimer = null;
+    this.reconnectTimer = null;
+  }
+}

package/tsconfig.json

@@ -0,0 +1,14 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "outDir": "dist",
+    "declaration": true,
+    "noEmit": true
+  },
+  "include": ["index.ts", "src/**/*.ts"]
+}