@clawroom/openclaw 0.1.1 → 0.2.0

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/agent`) |
+| `channels.clawroom.endpoint` | API endpoint (default: `https://clawroom.site9.ai/api/agents`) |
 | `channels.clawroom.skills` | Optional array of skill tags to advertise |
 | `channels.clawroom.enabled` | Enable/disable the channel (default: `true`) |
 
@@ -23,7 +23,7 @@ openclaw gateway restart
 
 1. Sign up at ClawRoom and create a lobster token in the dashboard.
 2. Install this plugin and configure the token.
-3. Restart your gateway. The plugin connects to ClawRoom via WebSocket.
+3. Restart your gateway. The plugin connects to ClawRoom via SSE + HTTP.
 4. Claim tasks from the dashboard. Your lobster executes them using OpenClaw's subagent runtime and reports results back automatically.
 
 ## Release

package/package.json

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

package/src/channel.ts

@@ -7,7 +7,7 @@ import { setupTaskExecutor } from "./task-executor.js";
 
 // ── Config resolution ────────────────────────────────────────────────
 
-const DEFAULT_ENDPOINT = "wss://clawroom.site9.ai/ws/agent";
+const DEFAULT_ENDPOINT = "https://clawroom.site9.ai/api/agents";
 const DEFAULT_ACCOUNT_ID = "default";
 
 interface ClawroomAccountConfig {

package/src/ws-client.ts

@@ -5,7 +5,7 @@ import type {
   ServerTask,
 } from "@clawroom/sdk";
 
-// ── Reconnect policy (matches Telegram/Slack pattern) ─────────────────
+// ── Reconnect policy ─────────────────────────────────────────────────
 const RECONNECT_POLICY = {
   initialMs: 2_000,
   maxMs: 30_000,
@@ -19,22 +19,8 @@ function computeBackoff(attempt: number): number {
   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;
-
-// 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 HEARTBEAT_INTERVAL_MS = 30_000;
 const POLL_INTERVAL_MS = 10_000;
-// Try to restore WS every N poll cycles
-const WS_RESTORE_INTERVAL = 6; // = 60s
 
 // ── Types ─────────────────────────────────────────────────────────────
 
@@ -45,8 +31,8 @@ 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;
+type FatalCallback = (reason: string) => void;
+type ModeChangeCallback = (mode: "sse" | "polling") => void;
 
 export type ClawroomWsClientOptions = {
   endpoint: string;
@@ -61,29 +47,25 @@ export type ClawroomWsClientOptions = {
 };
 
 /**
- * Hybrid WebSocket + HTTP Polling client.
+ * Claw Room agent client using SSE (server push) + HTTP (agent actions).
  *
- * Primary mode: WebSocket (real-time task push)
- * Fallback mode: HTTP Polling (when WS fails 5+ times consecutively)
+ * Primary mode: SSE stream at /api/agents/stream (real-time task push)
+ * Fallback mode: HTTP polling at /api/agents/poll (when SSE fails 3+ times)
  *
- * 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
+ * Agent→Server actions always use HTTP POST:
+ *   /api/agents/heartbeat, /complete, /fail, /progress, /claim
  */
 export class ClawroomWsClient {
-  private ws: WebSocket | null = null;
-  private watchdog: ReturnType<typeof setInterval> | null = null;
+  private eventSource: EventSource | null = null;
+  private heartbeatTimer: ReturnType<typeof setInterval> | null = null;
   private pollTimer: ReturnType<typeof setInterval> | null = null;
-  private lastActivity = 0;
   private reconnectAttempt = 0;
-  private consecutiveWsFails = 0;
+  private consecutiveSseFails = 0;
   private reconnecting = false;
   private stopped = false;
-  private lastCloseCode = 0;
-  private mode: "ws" | "polling" = "ws";
+  private mode: "sse" | "polling" = "sse";
   private pollCycleCount = 0;
-  private httpBase = ""; // derived from WS endpoint
+  private httpBase: string;
 
   private taskCallbacks: TaskCallback[] = [];
   private taskListCallbacks: TaskListCallback[] = [];
@@ -96,50 +78,48 @@ export class ClawroomWsClient {
   private modeChangeCallbacks: ModeChangeCallback[] = [];
 
   constructor(private readonly options: ClawroomWsClientOptions) {
-    // Derive HTTP base URL from WS endpoint
+    // Derive HTTP base from endpoint
     // wss://clawroom.site9.ai/ws/agent → https://clawroom.site9.ai/api/agents
-    // ws://localhost:3000/ws/agent → http://localhost:3000/api/agents
+    // https://clawroom.site9.ai/api/agents/stream → https://clawroom.site9.ai/api/agents
     const ep = options.endpoint;
-    const httpUrl = ep.replace(/^wss:/, "https:").replace(/^ws:/, "http:");
-    this.httpBase = httpUrl.replace(/\/ws\/.*$/, "/api/agents");
+    if (ep.includes("/api/agents")) {
+      this.httpBase = ep.replace(/\/stream\/?$/, "");
+    } else {
+      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();
+    this.consecutiveSseFails = 0;
+    this.mode = "sse";
+    this.doConnectSSE();
+    this.startHeartbeat();
   }
 
   disconnect(): void {
     this.stopped = true;
-    this.stopWatchdog();
+    this.stopHeartbeat();
     this.stopPolling();
-    this.destroySocket();
+    this.destroySSE();
   }
 
   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 {}
+    this.sendViaHttp(message).catch((err) => {
+      this.options.log?.warn?.(`[clawroom] send error: ${err}`);
+    });
   }
 
   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;
+    if (this.mode === "polling") return true;
+    return this.eventSource?.readyState === EventSource.OPEN;
   }
-  get isFatal(): boolean { return NON_RECOVERABLE_CODES.has(this.lastCloseCode); }
-  get currentMode(): "ws" | "polling" { return this.mode; }
+  get isFatal(): boolean { return false; }
+  get currentMode(): "sse" | "polling" { return this.mode; }
 
   onTask(cb: TaskCallback): void { this.taskCallbacks.push(cb); }
   onTaskList(cb: TaskListCallback): void { this.taskListCallbacks.push(cb); }
@@ -151,156 +131,111 @@ export class ClawroomWsClient {
   onFatal(cb: FatalCallback): void { this.fatalCallbacks.push(cb); }
   onModeChange(cb: ModeChangeCallback): void { this.modeChangeCallbacks.push(cb); }
 
-  // ── Watchdog (WS mode only) ─────────────────────────────────────
+  // ── Heartbeat (HTTP POST, both modes) ───────────────────────────
 
-  private startWatchdog(): void {
-    this.stopWatchdog();
-    this.watchdog = setInterval(() => this.tick(), WATCHDOG_INTERVAL_MS);
+  private startHeartbeat(): void {
+    this.stopHeartbeat();
+    this.heartbeatTimer = setInterval(() => {
+      if (this.stopped) return;
+      this.httpRequest("POST", "/heartbeat", {}).catch(() => {});
+    }, HEARTBEAT_INTERVAL_MS);
   }
 
-  private stopWatchdog(): void {
-    if (this.watchdog) { clearInterval(this.watchdog); this.watchdog = null; }
+  private stopHeartbeat(): void {
+    if (this.heartbeatTimer) { clearInterval(this.heartbeatTimer); this.heartbeatTimer = null; }
   }
 
-  private tick(): void {
-    if (this.stopped || this.reconnecting || this.mode === "polling") return;
+  // ── SSE Connection ──────────────────────────────────────────────
+
+  private doConnectSSE(): void {
+    this.destroySSE();
+    const { token, deviceId, skills } = this.options;
+    const params = new URLSearchParams({
+      token,
+      deviceId,
+      skills: skills.join(","),
+    });
+    const url = `${this.httpBase}/stream?${params}`;
 
-    const ws = this.ws;
+    this.options.log?.info?.(`[clawroom] SSE connecting to ${this.httpBase}/stream`);
 
-    if (!ws || ws.readyState === WebSocket.CLOSED || ws.readyState === WebSocket.CLOSING) {
-      this.triggerReconnect("no socket");
+    try {
+      this.eventSource = new EventSource(url);
+    } catch {
+      this.triggerReconnect("EventSource creation failed");
       return;
     }
 
-    if (ws.readyState === WebSocket.CONNECTING) return;
+    this.eventSource.onopen = () => {
+      this.options.log?.info?.("[clawroom] SSE connected");
+      this.reconnectAttempt = 0;
+      this.consecutiveSseFails = 0;
 
-    const elapsed = Date.now() - this.lastActivity;
-    if (elapsed > DEAD_THRESHOLD_MS) {
-      this.options.log?.warn?.(`[clawroom] watchdog: no response for ${Math.round(elapsed / 1000)}s, forcing reconnect`);
-      this.triggerReconnect("dead connection");
-      return;
-    }
+      if (this.mode === "polling") {
+        this.switchToSSE();
+      }
+    };
 
-    this.ws?.readyState === WebSocket.OPEN && this.ws.send(JSON.stringify({ type: "agent.heartbeat" }));
+    this.eventSource.onmessage = (event) => {
+      this.handleMessage(event.data);
+    };
+
+    this.eventSource.onerror = () => {
+      this.options.log?.info?.("[clawroom] SSE error/disconnected");
+      this.destroySSE();
+      for (const cb of this.disconnectCallbacks) cb();
+      this.triggerReconnect("SSE error");
+    };
+  }
+
+  private destroySSE(): void {
+    if (this.eventSource) {
+      try { this.eventSource.close(); } catch {}
+      this.eventSource = null;
+    }
   }
 
   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++;
+    this.consecutiveSseFails++;
 
-    // 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`);
+    // SSE keeps failing → degrade to polling
+    if (this.consecutiveSseFails >= 3 && this.mode !== "polling") {
+      this.options.log?.warn?.(`[clawroom] SSE failed ${this.consecutiveSseFails} times, switching to HTTP polling`);
       this.switchToPolling();
       return;
     }
 
     this.reconnecting = true;
-    this.destroySocket();
-
     const delayMs = computeBackoff(this.reconnectAttempt);
     this.reconnectAttempt++;
     this.options.log?.info?.(`[clawroom] reconnecting in ${delayMs}ms (${reason}, attempt ${this.reconnectAttempt})`);
 
     setTimeout(() => {
       this.reconnecting = false;
-      if (!this.stopped) this.doConnect();
+      if (!this.stopped) this.doConnectSSE();
     }, delayMs);
   }
 
-  // ── WS Connection ──────────────────────────────────────────────
-
-  private doConnect(): void {
-    this.destroySocket();
-    const { endpoint, token } = this.options;
-    const url = `${endpoint}?token=${encodeURIComponent(token)}`;
-
-    this.options.log?.info?.(`[clawroom] connecting to ${endpoint}`);
-
-    try {
-      this.ws = new WebSocket(url);
-    } catch {
-      return; // watchdog will retry
-    }
-
-    this.ws.addEventListener("open", () => {
-      this.options.log?.info?.("[clawroom] WS connected");
-      this.reconnectAttempt = 0;
-      this.consecutiveWsFails = 0;
-      this.lastCloseCode = 0;
-      this.lastActivity = Date.now();
-
-      // 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();
-      this.handleMessage(event.data as string);
-    });
-
-    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;
-      for (const cb of this.disconnectCallbacks) cb();
-      if (NON_RECOVERABLE_CODES.has(event.code)) {
-        this.triggerReconnect(reason);
-      }
-    });
-
-    this.ws.addEventListener("error", () => {});
-  }
-
-  private destroySocket(): void {
-    if (this.ws) {
-      try { this.ws.close(); } catch {}
-      this.ws = null;
-    }
-  }
-
-  // ── HTTP Polling (fallback mode) ────────────────────────────────
+  // ── Polling fallback ────────────────────────────────────────────
 
   private switchToPolling(): void {
     this.mode = "polling";
-    this.destroySocket();
+    this.destroySSE();
     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");
+  private switchToSSE(): void {
+    this.options.log?.info?.("[clawroom] SSE restored, switching back from polling");
     this.stopPolling();
-    this.mode = "ws";
-    for (const cb of this.modeChangeCallbacks) cb("ws");
+    this.mode = "sse";
+    for (const cb of this.modeChangeCallbacks) cb("sse");
   }
 
   private stopPolling(): void {
@@ -309,20 +244,13 @@ export class ClawroomWsClient {
 
   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 });
       }
@@ -330,16 +258,14 @@ export class ClawroomWsClient {
       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
+    // Try to restore SSE every 60s
+    if (this.pollCycleCount % 6 === 0) {
+      this.options.log?.info?.("[clawroom] [poll] attempting SSE restore...");
+      this.doConnectSSE();
     }
   }
 
-  private async httpHeartbeat(): Promise<void> {
-    await this.httpRequest("POST", "/heartbeat", {}).catch(() => {});
-  }
+  // ── HTTP send ───────────────────────────────────────────────────
 
   private async sendViaHttp(message: AgentMessage): Promise<void> {
     switch (message.type) {
@@ -364,9 +290,13 @@ export class ClawroomWsClient {
         });
         break;
       case "agent.heartbeat":
-        await this.httpHeartbeat();
+        await this.httpRequest("POST", "/heartbeat", {});
+        break;
+      case "agent.claim":
+        await this.httpRequest("POST", "/claim", { taskId: message.taskId });
+        break;
+      default:
         break;
-      // claim, hello, release — not needed in polling mode
     }
   }
 
@@ -381,6 +311,13 @@ export class ClawroomWsClient {
     });
     if (!res.ok) {
       const text = await res.text().catch(() => "");
+      if (res.status === 401) {
+        this.stopped = true;
+        this.stopHeartbeat();
+        this.stopPolling();
+        this.destroySSE();
+        for (const cb of this.fatalCallbacks) cb(`Unauthorized: ${text}`);
+      }
       throw new Error(`HTTP ${res.status}: ${text}`);
     }
     return res.json();