@clawroom/openclaw 0.1.0 → 0.1.1

package/README.md

@@ -15,7 +15,7 @@ openclaw gateway restart
 | Key | Description |
 |---|---|
 | `channels.clawroom.token` | Lobster token from the ClawRoom dashboard |
-| `channels.clawroom.endpoint` | WebSocket endpoint (default: `ws://localhost:3000/ws/lobster`) |
+| `channels.clawroom.endpoint` | WebSocket endpoint (default: `ws://localhost:3000/ws/agent`) |
 | `channels.clawroom.skills` | Optional array of skill tags to advertise |
 | `channels.clawroom.enabled` | Enable/disable the channel (default: `true`) |
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@clawroom/openclaw",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "OpenClaw channel plugin for the Claw Room task marketplace",
   "type": "module",
   "license": "MIT",

package/src/channel.ts

@@ -145,26 +145,93 @@ export const clawroomPlugin: ChannelPlugin<ResolvedClawroomAccount> = {
         log,
       });
 
+      // Track connection state for OpenClaw health monitor
+      const publishConnected = () => {
+        ctx.setStatus({
+          accountId: account.accountId,
+          running: true,
+          connected: true,
+          lastStartAt: Date.now(),
+          lastStopAt: null,
+          lastError: null,
+          lastEventAt: Date.now(),
+        });
+      };
+
+      const publishDisconnected = (error?: string) => {
+        ctx.setStatus({
+          accountId: account.accountId,
+          running: true,
+          connected: false,
+          lastStartAt: null,
+          lastStopAt: null,
+          lastError: error ?? "disconnected",
+        });
+      };
+
+      // Wire up WS events to OpenClaw health status
+      client.onWelcome(() => publishConnected());
+      client.onTask(() => {
+        // Any server message = update lastEventAt so gateway knows we're alive
+        ctx.setStatus({
+          accountId: account.accountId,
+          running: true,
+          connected: true,
+          lastEventAt: Date.now(),
+          lastStartAt: Date.now(),
+          lastStopAt: null,
+          lastError: null,
+        });
+      });
+      client.onDisconnect(() => publishDisconnected());
+      client.onModeChange((mode) => {
+        log?.info?.(`[clawroom] mode changed to ${mode}`);
+        ctx.setStatus({
+          accountId: account.accountId,
+          running: true,
+          connected: mode === "polling" ? true : client.isConnected,
+          lastEventAt: Date.now(),
+          lastStartAt: Date.now(),
+          lastStopAt: null,
+          lastError: mode === "polling" ? "degraded: HTTP polling" : null,
+        });
+      });
+      client.onFatal((reason, code) => {
+        log?.error?.(`[clawroom] fatal error (code ${code}): ${reason}`);
+        ctx.setStatus({
+          accountId: account.accountId,
+          running: false,
+          connected: false,
+          lastStopAt: Date.now(),
+          lastStartAt: null,
+          lastError: `Fatal: ${reason}`,
+        });
+      });
+
       setupTaskExecutor({ ws: client, runtime, log });
       client.connect();
       activeClient = client;
 
-      ctx.setStatus({
-        accountId: account.accountId,
-        running: true,
-        lastStartAt: Date.now(),
-        lastStopAt: null,
-        lastError: null,
-      });
+      publishDisconnected("connecting...");
+
+      // Health check: if client somehow stopped, restart it.
+      const healthCheck = setInterval(() => {
+        if (!client.isAlive) {
+          log?.warn?.("[clawroom] client died unexpectedly, restarting...");
+          client.connect();
+        }
+      }, 30_000);
 
       // Keep alive until gateway shuts down — only then disconnect
       await new Promise<void>((resolve) => {
         ctx.abortSignal.addEventListener("abort", () => {
+          clearInterval(healthCheck);
           client.disconnect();
           activeClient = null;
           ctx.setStatus({
             accountId: account.accountId,
             running: false,
+            connected: false,
             lastStartAt: null,
             lastStopAt: Date.now(),
             lastError: null,

package/src/ws-client.ts

@@ -5,17 +5,48 @@ import type {
   ServerTask,
 } from "@clawroom/sdk";
 
+// ── Reconnect policy (matches Telegram/Slack pattern) ─────────────────
+const RECONNECT_POLICY = {
+  initialMs: 2_000,
+  maxMs: 30_000,
+  factor: 1.8,
+  jitter: 0.25,
+};
+
+function computeBackoff(attempt: number): number {
+  const base = RECONNECT_POLICY.initialMs * RECONNECT_POLICY.factor ** Math.max(attempt - 1, 0);
+  const jitter = base * RECONNECT_POLICY.jitter * Math.random();
+  return Math.min(RECONNECT_POLICY.maxMs, Math.round(base + jitter));
+}
+
+// ── Non-recoverable close codes ───────────────────────────────────────
+const NON_RECOVERABLE_CODES = new Set([
+  4001, // Missing token
+  4002, // Invalid token
+  4003, // Token revoked / agent deleted
+]);
+
 const WATCHDOG_INTERVAL_MS = 10_000;
-const DEAD_THRESHOLD_MS = 25_000; // 2.5 missed heartbeats = dead
-const RECONNECT_BASE_MS = 1_000;
-const RECONNECT_MAX_MS = 30_000;
+const DEAD_THRESHOLD_MS = 25_000;
+
+// WS fails this many times in a row → switch to HTTP polling
+const WS_FAIL_THRESHOLD = 5;
+// HTTP poll interval when in degraded mode
+const POLL_INTERVAL_MS = 10_000;
+// Try to restore WS every N poll cycles
+const WS_RESTORE_INTERVAL = 6; // = 60s
+
+// ── Types ─────────────────────────────────────────────────────────────
 
 type TaskCallback = (task: ServerTask) => void;
 type TaskListCallback = (tasks: ServerTask[]) => void;
 type ClaimAckCallback = (ack: ServerClaimAck) => void;
 type ClaimRequestCallback = (task: ServerTask) => void;
 type ErrorCallback = (error: ServerMessage & { type: "server.error" }) => void;
+type DisconnectCallback = () => void;
 type WelcomeCallback = (agentId: string) => void;
+type FatalCallback = (reason: string, code: number) => void;
+type ModeChangeCallback = (mode: "ws" | "polling") => void;
 
 export type ClawroomWsClientOptions = {
   endpoint: string;
@@ -30,37 +61,57 @@ export type ClawroomWsClientOptions = {
 };
 
 /**
- * WebSocket client with aggressive reconnection.
+ * Hybrid WebSocket + HTTP Polling client.
+ *
+ * Primary mode: WebSocket (real-time task push)
+ * Fallback mode: HTTP Polling (when WS fails 5+ times consecutively)
  *
- * Watchdog strategy:
- * - Every 10s, send heartbeat and record the time
- * - Every 10s, check if last successful pong was > 25s ago
- * - If yes: server is dead. Destroy socket + HTTP verify + reconnect
- * - HTTP verify is fire-and-forget; reconnect is triggered regardless
- * - Watchdog NEVER stops unless disconnect() is called
+ * Automatically switches between modes:
+ *   - WS fails 5 times → degrade to polling
+ *   - While polling, try to restore WS every 60s
+ *   - WS reconnects successfully → switch back to WS, stop polling
  */
 export class ClawroomWsClient {
   private ws: WebSocket | null = null;
   private watchdog: ReturnType<typeof setInterval> | null = null;
-  private lastActivity = 0; // timestamp of last successful server response
+  private pollTimer: ReturnType<typeof setInterval> | null = null;
+  private lastActivity = 0;
   private reconnectAttempt = 0;
+  private consecutiveWsFails = 0;
   private reconnecting = false;
   private stopped = false;
+  private lastCloseCode = 0;
+  private mode: "ws" | "polling" = "ws";
+  private pollCycleCount = 0;
+  private httpBase = ""; // derived from WS endpoint
 
   private taskCallbacks: TaskCallback[] = [];
   private taskListCallbacks: TaskListCallback[] = [];
   private claimAckCallbacks: ClaimAckCallback[] = [];
   private claimRequestCallbacks: ClaimRequestCallback[] = [];
   private errorCallbacks: ErrorCallback[] = [];
+  private disconnectCallbacks: DisconnectCallback[] = [];
   private welcomeCallbacks: WelcomeCallback[] = [];
-
-  constructor(private readonly options: ClawroomWsClientOptions) {}
+  private fatalCallbacks: FatalCallback[] = [];
+  private modeChangeCallbacks: ModeChangeCallback[] = [];
+
+  constructor(private readonly options: ClawroomWsClientOptions) {
+    // Derive HTTP base URL from WS endpoint
+    // wss://clawroom.site9.ai/ws/agent → https://clawroom.site9.ai/api/agents
+    // ws://localhost:3000/ws/agent → http://localhost:3000/api/agents
+    const ep = options.endpoint;
+    const httpUrl = ep.replace(/^wss:/, "https:").replace(/^ws:/, "http:");
+    this.httpBase = httpUrl.replace(/\/ws\/.*$/, "/api/agents");
+  }
 
   connect(): void {
     this.stopped = false;
     this.reconnecting = false;
     this.reconnectAttempt = 0;
+    this.consecutiveWsFails = 0;
     this.lastActivity = Date.now();
+    this.lastCloseCode = 0;
+    this.mode = "ws";
     this.doConnect();
     this.startWatchdog();
   }
@@ -68,22 +119,39 @@ export class ClawroomWsClient {
   disconnect(): void {
     this.stopped = true;
     this.stopWatchdog();
+    this.stopPolling();
     this.destroySocket();
   }
 
   send(message: AgentMessage): void {
+    if (this.mode === "polling") {
+      // In polling mode, send via HTTP
+      this.sendViaHttp(message).catch(() => {});
+      return;
+    }
     if (!this.ws || this.ws.readyState !== WebSocket.OPEN) return;
     try { this.ws.send(JSON.stringify(message)); } catch {}
   }
 
+  get isAlive(): boolean { return !this.stopped; }
+  get isConnected(): boolean {
+    if (this.mode === "polling") return true; // polling is always "connected"
+    return this.ws?.readyState === WebSocket.OPEN;
+  }
+  get isFatal(): boolean { return NON_RECOVERABLE_CODES.has(this.lastCloseCode); }
+  get currentMode(): "ws" | "polling" { return this.mode; }
+
   onTask(cb: TaskCallback): void { this.taskCallbacks.push(cb); }
   onTaskList(cb: TaskListCallback): void { this.taskListCallbacks.push(cb); }
   onClaimAck(cb: ClaimAckCallback): void { this.claimAckCallbacks.push(cb); }
   onClaimRequest(cb: ClaimRequestCallback): void { this.claimRequestCallbacks.push(cb); }
   onError(cb: ErrorCallback): void { this.errorCallbacks.push(cb); }
+  onDisconnect(cb: DisconnectCallback): void { this.disconnectCallbacks.push(cb); }
   onWelcome(cb: WelcomeCallback): void { this.welcomeCallbacks.push(cb); }
+  onFatal(cb: FatalCallback): void { this.fatalCallbacks.push(cb); }
+  onModeChange(cb: ModeChangeCallback): void { this.modeChangeCallbacks.push(cb); }
 
-  // ── Watchdog ──────────────────────────────────────────────────────
+  // ── Watchdog (WS mode only) ─────────────────────────────────────
 
   private startWatchdog(): void {
     this.stopWatchdog();
@@ -94,43 +162,55 @@ export class ClawroomWsClient {
     if (this.watchdog) { clearInterval(this.watchdog); this.watchdog = null; }
   }
 
-  /** Synchronous tick — no async, no promises, no way to silently fail. */
   private tick(): void {
-    if (this.stopped) return;
-
-    // If already reconnecting, skip
-    if (this.reconnecting) return;
+    if (this.stopped || this.reconnecting || this.mode === "polling") return;
 
     const ws = this.ws;
 
-    // No socket → reconnect
     if (!ws || ws.readyState === WebSocket.CLOSED || ws.readyState === WebSocket.CLOSING) {
       this.triggerReconnect("no socket");
       return;
     }
 
-    // Still connecting → wait
     if (ws.readyState === WebSocket.CONNECTING) return;
 
-    // Socket is OPEN — check if server is responsive
     const elapsed = Date.now() - this.lastActivity;
     if (elapsed > DEAD_THRESHOLD_MS) {
-      // No response from server in 25s — it's dead
       this.options.log?.warn?.(`[clawroom] watchdog: no response for ${Math.round(elapsed / 1000)}s, forcing reconnect`);
       this.triggerReconnect("dead connection");
       return;
     }
 
-    // Send heartbeat
-    this.send({ type: "agent.heartbeat" });
+    this.ws?.readyState === WebSocket.OPEN && this.ws.send(JSON.stringify({ type: "agent.heartbeat" }));
   }
 
   private triggerReconnect(reason: string): void {
     if (this.reconnecting || this.stopped) return;
+
+    // Non-recoverable error
+    if (NON_RECOVERABLE_CODES.has(this.lastCloseCode)) {
+      const msg = `non-recoverable close code ${this.lastCloseCode}, giving up`;
+      this.options.log?.error?.(`[clawroom] ${msg}`);
+      this.stopped = true;
+      this.stopWatchdog();
+      this.stopPolling();
+      for (const cb of this.fatalCallbacks) cb(msg, this.lastCloseCode);
+      return;
+    }
+
+    this.consecutiveWsFails++;
+
+    // Too many WS failures → degrade to HTTP polling
+    if (this.consecutiveWsFails >= WS_FAIL_THRESHOLD && this.mode !== "polling") {
+      this.options.log?.warn?.(`[clawroom] WS failed ${this.consecutiveWsFails} times, switching to HTTP polling`);
+      this.switchToPolling();
+      return;
+    }
+
     this.reconnecting = true;
     this.destroySocket();
 
-    const delayMs = Math.min(RECONNECT_BASE_MS * 2 ** this.reconnectAttempt, RECONNECT_MAX_MS);
+    const delayMs = computeBackoff(this.reconnectAttempt);
     this.reconnectAttempt++;
     this.options.log?.info?.(`[clawroom] reconnecting in ${delayMs}ms (${reason}, attempt ${this.reconnectAttempt})`);
 
@@ -140,7 +220,7 @@ export class ClawroomWsClient {
     }, delayMs);
   }
 
-  // ── Connection ────────────────────────────────────────────────────
+  // ── WS Connection ──────────────────────────────────────────────
 
   private doConnect(): void {
     this.destroySocket();
@@ -156,30 +236,41 @@ export class ClawroomWsClient {
     }
 
     this.ws.addEventListener("open", () => {
-      this.options.log?.info?.("[clawroom] connected");
+      this.options.log?.info?.("[clawroom] WS connected");
       this.reconnectAttempt = 0;
+      this.consecutiveWsFails = 0;
+      this.lastCloseCode = 0;
       this.lastActivity = Date.now();
-      this.send({
+
+      // If we were polling, switch back to WS
+      if (this.mode === "polling") {
+        this.switchToWs();
+      }
+
+      this.ws?.send(JSON.stringify({
         type: "agent.hello",
         deviceId: this.options.deviceId,
         skills: this.options.skills,
-      });
+      }));
     });
 
     this.ws.addEventListener("message", (event) => {
-      this.lastActivity = Date.now(); // ANY message = server is alive
+      this.lastActivity = Date.now();
       this.handleMessage(event.data as string);
     });
 
-    this.ws.addEventListener("close", () => {
-      this.options.log?.info?.("[clawroom] disconnected");
+    this.ws.addEventListener("close", (event) => {
+      this.lastCloseCode = event.code;
+      const reason = event.reason || `code ${event.code}`;
+      this.options.log?.info?.(`[clawroom] WS disconnected (${reason})`);
       this.ws = null;
-      // Don't reconnect here — watchdog handles it
+      for (const cb of this.disconnectCallbacks) cb();
+      if (NON_RECOVERABLE_CODES.has(event.code)) {
+        this.triggerReconnect(reason);
+      }
     });
 
-    this.ws.addEventListener("error", () => {
-      // watchdog handles it
-    });
+    this.ws.addEventListener("error", () => {});
   }
 
   private destroySocket(): void {
@@ -189,6 +280,112 @@ export class ClawroomWsClient {
     }
   }
 
+  // ── HTTP Polling (fallback mode) ────────────────────────────────
+
+  private switchToPolling(): void {
+    this.mode = "polling";
+    this.destroySocket();
+    this.options.log?.info?.("[clawroom] entering HTTP polling mode");
+    for (const cb of this.modeChangeCallbacks) cb("polling");
+
+    // Send initial heartbeat
+    this.httpHeartbeat().catch(() => {});
+
+    this.pollCycleCount = 0;
+    this.stopPolling();
+    this.pollTimer = setInterval(() => this.pollTick(), POLL_INTERVAL_MS);
+  }
+
+  private switchToWs(): void {
+    this.options.log?.info?.("[clawroom] WS restored, switching back from polling");
+    this.stopPolling();
+    this.mode = "ws";
+    for (const cb of this.modeChangeCallbacks) cb("ws");
+  }
+
+  private stopPolling(): void {
+    if (this.pollTimer) { clearInterval(this.pollTimer); this.pollTimer = null; }
+  }
+
+  private async pollTick(): Promise<void> {
+    if (this.stopped) return;
+
+    this.pollCycleCount++;
+
+    // Heartbeat
+    await this.httpHeartbeat().catch(() => {});
+
+    // Poll for tasks — task-executor handles execution via callbacks
+    // (poll endpoint auto-claims, so we just need to trigger task callbacks)
+    try {
+      const res = await this.httpRequest("POST", "/poll", {});
+      if (res.task) {
+        const task = res.task as ServerTask;
+        this.options.log?.info?.(`[clawroom] [poll] received task ${task.taskId}: ${task.title}`);
+        // Fire task + claim_ack callbacks so task-executor picks it up
+        for (const cb of this.taskCallbacks) cb(task);
+        for (const cb of this.claimAckCallbacks) cb({ type: "server.claim_ack", taskId: task.taskId, ok: true });
+      }
+    } catch (err) {
+      this.options.log?.warn?.(`[clawroom] [poll] error: ${err}`);
+    }
+
+    // Periodically try to restore WS
+    if (this.pollCycleCount % WS_RESTORE_INTERVAL === 0) {
+      this.options.log?.info?.("[clawroom] [poll] attempting WS restore...");
+      this.doConnect(); // if WS connects, switchToWs() is called from open handler
+    }
+  }
+
+  private async httpHeartbeat(): Promise<void> {
+    await this.httpRequest("POST", "/heartbeat", {}).catch(() => {});
+  }
+
+  private async sendViaHttp(message: AgentMessage): Promise<void> {
+    switch (message.type) {
+      case "agent.complete":
+        await this.httpRequest("POST", "/complete", {
+          taskId: message.taskId,
+          output: message.output,
+          attachments: message.attachments,
+        });
+        break;
+      case "agent.fail":
+        await this.httpRequest("POST", "/fail", {
+          taskId: message.taskId,
+          reason: message.reason,
+        });
+        break;
+      case "agent.progress":
+        await this.httpRequest("POST", "/progress", {
+          taskId: message.taskId,
+          message: message.message,
+          percent: message.percent,
+        });
+        break;
+      case "agent.heartbeat":
+        await this.httpHeartbeat();
+        break;
+      // claim, hello, release — not needed in polling mode
+    }
+  }
+
+  private async httpRequest(method: string, path: string, body: unknown): Promise<any> {
+    const res = await fetch(`${this.httpBase}${path}`, {
+      method,
+      headers: {
+        "Content-Type": "application/json",
+        "Authorization": `Bearer ${this.options.token}`,
+      },
+      body: JSON.stringify(body),
+    });
+    if (!res.ok) {
+      const text = await res.text().catch(() => "");
+      throw new Error(`HTTP ${res.status}: ${text}`);
+    }
+    return res.json();
+  }
+
   // ── Message handling ──────────────────────────────────────────────
 
   private handleMessage(raw: string): void {
@@ -201,7 +398,6 @@ export class ClawroomWsClient {
         for (const cb of this.welcomeCallbacks) cb(msg.agentId);
         break;
       case "server.pong":
-        // lastActivity already updated in message handler
         break;
       case "server.task":
         this.options.log?.info?.(`[clawroom] received task ${msg.taskId}: ${msg.title}`);