@clawzone/clawzone 1.4.8 → 1.4.9

package/index.ts

@@ -167,7 +167,62 @@ export default {
           return { content: [{ type: "text", text: JSON.stringify({ status: "cancelled", match_id: resolution.match_id, reason: resolution.reason }) }] };
         }
 
-        // Still waiting after 10s — opponent hasn't moved yet. Use cron to poll.
+        // action_applied: opponent moved, now check via REST if it's our turn.
+        // This falls through to the REST poll below.
+
+        // Still waiting after 10s (or action_applied received) — check via REST.
+        // Fall back to REST poll to avoid getting stuck indefinitely.
+        try {
+          const { serverUrl, apiKey } = config;
+          const stateRes = await fetch(`${serverUrl}/api/v1/matches/${matchId}/state`, {
+            headers: { Authorization: `Bearer ${apiKey}` },
+          });
+
+          if (stateRes.ok) {
+            const data = await stateRes.json() as {
+              turn: number;
+              status: string;
+              state: unknown;
+              available_actions: Array<{ type: string; payload: unknown }>;
+            };
+
+            if (data.available_actions && data.available_actions.length > 0) {
+              // It IS our turn — WS event was missed. Sync local state.
+              state.setYourTurnFromREST(matchId, data.turn, data.state, data.available_actions);
+              return { content: [{ type: "text", text: JSON.stringify({
+                status: "your_turn",
+                match_id: matchId,
+                turn: data.turn,
+                state: data.state,
+                available_actions: data.available_actions,
+              }) }] };
+            }
+
+            if (data.status === "finished" || data.status === "cancelled") {
+              return { content: [{ type: "text", text: JSON.stringify({
+                status: data.status,
+                match_id: matchId,
+              }) }] };
+            }
+          } else if (stateRes.status === 404) {
+            // Session no longer active — match may have ended
+            const matchRes = await fetch(`${serverUrl}/api/v1/matches/${matchId}`, {
+              headers: { Authorization: `Bearer ${apiKey}` },
+            });
+            if (matchRes.ok) {
+              const match = await matchRes.json() as { status: string };
+              if (match.status === "finished" || match.status === "cancelled") {
+                return { content: [{ type: "text", text: JSON.stringify({
+                  status: match.status,
+                  match_id: matchId,
+                }) }] };
+              }
+            }
+          }
+        } catch (_e) {
+          // REST fallback failed — fall through to "waiting"
+        }
+
         return { content: [{ type: "text", text: JSON.stringify({
           status: "waiting",
           match_id: matchId,
@@ -252,7 +307,9 @@ export default {
         let resolution = await resolutionPromise;
         totalWaited += WAIT_INTERVAL;
 
-        while (resolution.type === "timeout" && totalWaited < MAX_TOTAL_WAIT) {
+        // Continue waiting on action_applied (our own move confirmed but opponent hasn't moved yet)
+        // as well as timeout — both mean "still waiting for next turn event".
+        while ((resolution.type === "timeout" || resolution.type === "action_applied") && totalWaited < MAX_TOTAL_WAIT) {
           // Check if state was updated (event arrived between waits)
           const currentMatch = state.getMatch(matchId);
           if (currentMatch) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@clawzone/clawzone",
-  "version": "1.4.8",
+  "version": "1.4.9",
   "description": "OpenClaw plugin for ClawZone — real-time competitive AI gaming via WebSocket",
   "main": "index.ts",
   "openclaw": {

package/src/state.ts

@@ -7,6 +7,7 @@ import type {
   YourTurnPayload,
   MatchFinishedPayload,
   MatchCancelledPayload,
+  ActionAppliedPayload,
 } from "./types";
 
 type MatchResolver = (match: { matchId: string; players: string[] }) => void;
@@ -15,7 +16,8 @@ export type TurnResolution =
   | { type: "your_turn"; match_id: string; turn: number; state: unknown; available_actions: YourTurnAction[] }
   | { type: "finished"; match_id: string; result: MatchResult | null; your_result: YourResult | null; spectator_view: unknown }
   | { type: "cancelled"; match_id: string; reason: string | null }
-  | { type: "timeout"; match_id: string };
+  | { type: "timeout"; match_id: string }
+  | { type: "action_applied"; match_id: string };
 
 type TurnResolver = (resolution: TurnResolution) => void;
 
@@ -91,6 +93,17 @@ export class MatchStateManager {
     }
   }
 
+  // Called when any agent makes a move (including the opponent).
+  // Wakes up any waiting clawzone_status call so it can do a REST check immediately.
+  onActionApplied(payload: ActionAppliedPayload): void {
+    const { match_id } = payload;
+    const waiter = this.turnWaiters.get(match_id);
+    if (waiter) {
+      this.turnWaiters.delete(match_id);
+      waiter({ type: "action_applied", match_id });
+    }
+  }
+
   onMatchCancelled(payload: MatchCancelledPayload): void {
     const { match_id, reason } = payload;
     const match = this.matches.get(match_id);
@@ -153,6 +166,17 @@ export class MatchStateManager {
     });
   }
 
+  // Called when REST poll reveals it's our turn (WS event was missed).
+  setYourTurnFromREST(matchId: string, turn: number, agentView: unknown, availableActions: YourTurnAction[]): void {
+    const match = this.matches.get(matchId);
+    if (match) {
+      match.turn = turn;
+      match.yourTurn = true;
+      match.agentView = agentView;
+      match.availableActions = availableActions;
+    }
+  }
+
   cleanup(matchId: string): void {
     this.matches.delete(matchId);
     if (this.currentMatchId === matchId) {

package/src/ws-client.ts

@@ -6,6 +6,7 @@ import type {
   YourTurnPayload,
   MatchFinishedPayload,
   MatchCancelledPayload,
+  ActionAppliedPayload,
   Logger,
 } from "./types";
 
@@ -88,7 +89,9 @@ export class ClawZoneWSClient {
         break;
 
       case "action_applied":
-        // Informational — opponent or self action applied (no action details, fog of war)
+        // An action was applied — wake up any waiting status poll so it can
+        // immediately check via REST whether it's now our turn.
+        this.state.onActionApplied(msg.payload as ActionAppliedPayload);
         break;
 
       case "turn_timeout":