@clawroom/openclaw 0.1.0 → 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/lobster`) |
+| `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.0",
+  "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 {
@@ -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,34 @@ import type {
   ServerTask,
 } from "@clawroom/sdk";
 
-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;
+// ── Reconnect policy ─────────────────────────────────────────────────
+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));
+}
+
+const HEARTBEAT_INTERVAL_MS = 30_000;
+const POLL_INTERVAL_MS = 10_000;
+
+// ── 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) => void;
+type ModeChangeCallback = (mode: "sse" | "polling") => void;
 
 export type ClawroomWsClientOptions = {
   endpoint: string;
@@ -30,163 +47,280 @@ export type ClawroomWsClientOptions = {
 };
 
 /**
- * WebSocket client with aggressive reconnection.
+ * Claw Room agent client using SSE (server push) + HTTP (agent actions).
+ *
+ * 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)
  *
- * 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
+ * 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 lastActivity = 0; // timestamp of last successful server response
+  private eventSource: EventSource | null = null;
+  private heartbeatTimer: ReturnType<typeof setInterval> | null = null;
+  private pollTimer: ReturnType<typeof setInterval> | null = null;
   private reconnectAttempt = 0;
+  private consecutiveSseFails = 0;
   private reconnecting = false;
   private stopped = false;
+  private mode: "sse" | "polling" = "sse";
+  private pollCycleCount = 0;
+  private httpBase: string;
 
   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 from endpoint
+    // wss://clawroom.site9.ai/ws/agent → https://clawroom.site9.ai/api/agents
+    // https://clawroom.site9.ai/api/agents/stream → https://clawroom.site9.ai/api/agents
+    const ep = options.endpoint;
+    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.lastActivity = Date.now();
-    this.doConnect();
-    this.startWatchdog();
+    this.consecutiveSseFails = 0;
+    this.mode = "sse";
+    this.doConnectSSE();
+    this.startHeartbeat();
   }
 
   disconnect(): void {
     this.stopped = true;
-    this.stopWatchdog();
-    this.destroySocket();
+    this.stopHeartbeat();
+    this.stopPolling();
+    this.destroySSE();
   }
 
   send(message: AgentMessage): void {
-    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;
+    return this.eventSource?.readyState === EventSource.OPEN;
+  }
+  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); }
   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 ──────────────────────────────────────────────────────
+  // ── 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; }
   }
 
-  /** Synchronous tick — no async, no promises, no way to silently fail. */
-  private tick(): void {
-    if (this.stopped) return;
+  // ── SSE Connection ──────────────────────────────────────────────
 
-    // If already reconnecting, skip
-    if (this.reconnecting) return;
+  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`);
 
-    // No socket → reconnect
-    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;
     }
 
-    // Still connecting → wait
-    if (ws.readyState === WebSocket.CONNECTING) return;
+    this.eventSource.onopen = () => {
+      this.options.log?.info?.("[clawroom] SSE connected");
+      this.reconnectAttempt = 0;
+      this.consecutiveSseFails = 0;
+
+      if (this.mode === "polling") {
+        this.switchToSSE();
+      }
+    };
+
+    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");
+    };
+  }
 
-    // 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;
+  private destroySSE(): void {
+    if (this.eventSource) {
+      try { this.eventSource.close(); } catch {}
+      this.eventSource = null;
     }
-
-    // Send heartbeat
-    this.send({ type: "agent.heartbeat" });
   }
 
   private triggerReconnect(reason: string): void {
     if (this.reconnecting || this.stopped) return;
-    this.reconnecting = true;
-    this.destroySocket();
 
-    const delayMs = Math.min(RECONNECT_BASE_MS * 2 ** this.reconnectAttempt, RECONNECT_MAX_MS);
+    this.consecutiveSseFails++;
+
+    // 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;
+    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);
   }
 
-  // ── Connection ────────────────────────────────────────────────────
+  // ── Polling fallback ────────────────────────────────────────────
 
-  private doConnect(): void {
-    this.destroySocket();
-    const { endpoint, token } = this.options;
-    const url = `${endpoint}?token=${encodeURIComponent(token)}`;
+  private switchToPolling(): void {
+    this.mode = "polling";
+    this.destroySSE();
+    this.options.log?.info?.("[clawroom] entering HTTP polling mode");
+    for (const cb of this.modeChangeCallbacks) cb("polling");
 
-    this.options.log?.info?.(`[clawroom] connecting to ${endpoint}`);
+    this.pollCycleCount = 0;
+    this.stopPolling();
+    this.pollTimer = setInterval(() => this.pollTick(), POLL_INTERVAL_MS);
+  }
+
+  private switchToSSE(): void {
+    this.options.log?.info?.("[clawroom] SSE restored, switching back from polling");
+    this.stopPolling();
+    this.mode = "sse";
+    for (const cb of this.modeChangeCallbacks) cb("sse");
+  }
+
+  private stopPolling(): void {
+    if (this.pollTimer) { clearInterval(this.pollTimer); this.pollTimer = null; }
+  }
+
+  private async pollTick(): Promise<void> {
+    if (this.stopped) return;
+    this.pollCycleCount++;
 
     try {
-      this.ws = new WebSocket(url);
-    } catch {
-      return; // watchdog will retry
+      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}`);
+        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}`);
     }
 
-    this.ws.addEventListener("open", () => {
-      this.options.log?.info?.("[clawroom] connected");
-      this.reconnectAttempt = 0;
-      this.lastActivity = Date.now();
-      this.send({
-        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.handleMessage(event.data as string);
-    });
+    // Try to restore SSE every 60s
+    if (this.pollCycleCount % 6 === 0) {
+      this.options.log?.info?.("[clawroom] [poll] attempting SSE restore...");
+      this.doConnectSSE();
+    }
+  }
 
-    this.ws.addEventListener("close", () => {
-      this.options.log?.info?.("[clawroom] disconnected");
-      this.ws = null;
-      // Don't reconnect here — watchdog handles it
-    });
+  // ── HTTP send ───────────────────────────────────────────────────
 
-    this.ws.addEventListener("error", () => {
-      // watchdog handles it
-    });
+  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.httpRequest("POST", "/heartbeat", {});
+        break;
+      case "agent.claim":
+        await this.httpRequest("POST", "/claim", { taskId: message.taskId });
+        break;
+      default:
+        break;
+    }
   }
 
-  private destroySocket(): void {
-    if (this.ws) {
-      try { this.ws.close(); } catch {}
-      this.ws = null;
+  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(() => "");
+      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();
   }
 
   // ── Message handling ──────────────────────────────────────────────
@@ -201,7 +335,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}`);