@clawroom/openclaw 0.1.1 → 0.2.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/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.1",
   "description": "OpenClaw channel plugin for the Claw Room task marketplace",
   "type": "module",
   "license": "MIT",

package/src/channel.ts

@@ -2,12 +2,12 @@ import type { ChannelPlugin } from "openclaw/plugin-sdk/core";
 import type { OpenClawConfig } from "openclaw/plugin-sdk/core";
 import { collectSkills } from "./skill-reporter.js";
 import { getClawroomRuntime } from "./runtime.js";
-import { ClawroomWsClient } from "./ws-client.js";
+import { ClawroomClient } from "./client.js";
 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 {
@@ -54,9 +54,9 @@ function resolveClawroomAccount(opts: {
   };
 }
 
-// ── Persistent WS client per gateway lifecycle ───────────────────────
+// ── Persistent client per gateway lifecycle ───────────────────────
 
-let activeClient: ClawroomWsClient | null = null;
+let activeClient: ClawroomClient | null = null;
 
 // ── Channel plugin definition ────────────────────────────────────────
 
@@ -103,8 +103,8 @@ export const clawroomPlugin: ChannelPlugin<ResolvedClawroomAccount> = {
     deliveryMode: "direct",
 
     sendText: async ({ to, text }) => {
-      // Outbound messages are task results sent via the WS client.
-      // The task-executor sends results directly through ws.send();
+      // Outbound messages are task results sent via HTTP.
+      // The task-executor sends results directly through client.send();
       // this adapter exists for completeness if openclaw routing tries
       // to deliver a reply through the channel outbound path.
       if (activeClient) {
@@ -137,7 +137,7 @@ export const clawroomPlugin: ChannelPlugin<ResolvedClawroomAccount> = {
       const deviceId = resolveDeviceId(ctx);
       const log = ctx.log ?? undefined;
 
-      const client = new ClawroomWsClient({
+      const client = new ClawroomClient({
         endpoint: account.endpoint,
         token: account.token,
         deviceId,
@@ -169,7 +169,7 @@ export const clawroomPlugin: ChannelPlugin<ResolvedClawroomAccount> = {
         });
       };
 
-      // Wire up WS events to OpenClaw health status
+      // Wire up SSE events to OpenClaw health status
       client.onWelcome(() => publishConnected());
       client.onTask(() => {
         // Any server message = update lastEventAt so gateway knows we're alive
@@ -208,7 +208,7 @@ export const clawroomPlugin: ChannelPlugin<ResolvedClawroomAccount> = {
         });
       });
 
-      setupTaskExecutor({ ws: client, runtime, log });
+      setupTaskExecutor({ client: client, runtime, log });
       client.connect();
       activeClient = client;
 

package/src/{ws-client.ts → 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,10 +31,10 @@ 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 = {
+export type ClawroomClientOptions = {
   endpoint: string;
   token: string;
   deviceId: string;
@@ -61,29 +47,24 @@ 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;
+export class ClawroomClient {
+  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[] = [];
@@ -95,51 +76,49 @@ export class ClawroomWsClient {
   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
+  constructor(private readonly options: ClawroomClientOptions) {
+    // Derive HTTP base from endpoint
+    // Legacy: wss://host/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;
-    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.sseAbort !== null && !this.sseAbort.signal.aborted;
   }
-  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 +130,135 @@ 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;
-
-    const ws = this.ws;
+  // ── SSE Connection (fetch-based, works in Node.js) ───────────────
+
+  private sseAbort: AbortController | null = null;
+
+  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}`;
+
+    this.options.log?.info?.(`[clawroom] SSE connecting to ${this.httpBase}/stream`);
+
+    this.sseAbort = new AbortController();
+    const signal = this.sseAbort.signal;
+
+    fetch(url, {
+      headers: { "Accept": "text/event-stream", "Authorization": `Bearer ${token}` },
+      signal,
+    }).then(async (res) => {
+      if (!res.ok || !res.body) {
+        if (res.status === 401) {
+          this.stopped = true;
+          this.stopHeartbeat();
+          this.stopPolling();
+          for (const cb of this.fatalCallbacks) cb("Unauthorized");
+          return;
+        }
+        throw new Error(`HTTP ${res.status}`);
+      }
 
-    if (!ws || ws.readyState === WebSocket.CLOSED || ws.readyState === WebSocket.CLOSING) {
-      this.triggerReconnect("no socket");
-      return;
-    }
+      this.options.log?.info?.("[clawroom] SSE connected");
+      this.reconnectAttempt = 0;
+      this.consecutiveSseFails = 0;
+      if (this.mode === "polling") this.switchToSSE();
+
+      const reader = res.body.getReader();
+      const decoder = new TextDecoder();
+      let buffer = "";
+
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split("\n");
+        buffer = lines.pop() ?? "";
+
+        for (const line of lines) {
+          if (line.startsWith("data: ")) {
+            this.handleMessage(line.slice(6));
+          }
+          // Ignore comments (: keepalive) and empty lines
+        }
+      }
 
-    if (ws.readyState === WebSocket.CONNECTING) return;
+      // Stream ended
+      this.options.log?.info?.("[clawroom] SSE stream ended");
+      for (const cb of this.disconnectCallbacks) cb();
+      this.triggerReconnect("stream ended");
+    }).catch((err) => {
+      if (signal.aborted) return;
+      this.options.log?.warn?.(`[clawroom] SSE error: ${err}`);
+      for (const cb of this.disconnectCallbacks) cb();
+      this.triggerReconnect("SSE error");
+    });
+  }
 
-    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;
+  private destroySSE(): void {
+    if (this.sseAbort) {
+      try { this.sseAbort.abort(); } catch {}
+      this.sseAbort = null;
     }
-
-    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++;
+    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 +267,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 +281,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 +313,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 +334,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();

package/src/task-executor.ts

@@ -1,6 +1,6 @@
 import type { ServerClaimAck, ServerTask, AgentResultFile } from "@clawroom/sdk";
 import type { PluginRuntime } from "openclaw/plugin-sdk/core";
-import type { ClawroomWsClient } from "./ws-client.js";
+import type { ClawroomClient } from "./client.js";
 import fs from "node:fs";
 import path from "node:path";
 
@@ -18,7 +18,7 @@ const MAX_FILE_SIZE = 10 * 1024 * 1024;
  * Claiming is triggered externally (by the owner via Dashboard).
  */
 export function setupTaskExecutor(opts: {
-  ws: ClawroomWsClient;
+  client: ClawroomClient;
   runtime: PluginRuntime;
   log?: {
     info?: (...args: unknown[]) => void;
@@ -26,19 +26,19 @@ export function setupTaskExecutor(opts: {
     error?: (...args: unknown[]) => void;
   };
 }): void {
-  const { ws, runtime, log } = opts;
+  const { client, runtime, log } = opts;
 
   // Track received tasks (from broadcast or server push after claim)
   const knownTasks = new Map<string, ServerTask>();
 
   // New task received — store it for potential execution
-  ws.onTask((task: ServerTask) => {
+  client.onTask((task: ServerTask) => {
     log?.info?.(`[clawroom:executor] received task ${task.taskId}: ${task.title}`);
     knownTasks.set(task.taskId, task);
   });
 
   // Task list on connect — store all
-  ws.onTaskList((tasks: ServerTask[]) => {
+  client.onTaskList((tasks: ServerTask[]) => {
     log?.info?.(`[clawroom:executor] ${tasks.length} open task(s) available`);
     for (const t of tasks) {
       log?.info?.(`[clawroom:executor]   - ${t.taskId}: ${t.title}`);
@@ -47,7 +47,7 @@ export function setupTaskExecutor(opts: {
   });
 
   // Claim ack — either from plugin-initiated claim or Dashboard-initiated claim
-  ws.onClaimAck((ack: ServerClaimAck) => {
+  client.onClaimAck((ack: ServerClaimAck) => {
     if (!ack.ok) {
       log?.warn?.(
         `[clawroom:executor] claim rejected for ${ack.taskId}: ${ack.reason ?? "unknown"}`,
@@ -67,7 +67,7 @@ export function setupTaskExecutor(opts: {
     }
 
     log?.info?.(`[clawroom:executor] executing task ${task.taskId}`);
-    void executeTask({ ws, runtime, task, log });
+    void executeTask({ client, runtime, task, log });
   });
 }
 
@@ -76,7 +76,7 @@ export function setupTaskExecutor(opts: {
  * result back to the ClawRoom server.
  */
 async function executeTask(opts: {
-  ws: ClawroomWsClient;
+  client: ClawroomClient;
   runtime: PluginRuntime;
   task: ServerTask;
   log?: {
@@ -84,7 +84,7 @@ async function executeTask(opts: {
     error?: (...args: unknown[]) => void;
   };
 }): Promise<void> {
-  const { ws, runtime, task, log } = opts;
+  const { client, runtime, task, log } = opts;
   const sessionKey = `clawroom:task:${task.taskId}`;
 
   const agentMessage = buildAgentMessage(task);
@@ -116,7 +116,7 @@ async function executeTask(opts: {
       log?.error?.(
         `[clawroom:executor] subagent error for task ${task.taskId}: ${waitResult.error}`,
       );
-      ws.send({
+      client.send({
         type: "agent.fail",
         taskId: task.taskId,
         reason: waitResult.error ?? "Agent execution failed",
@@ -126,7 +126,7 @@ async function executeTask(opts: {
 
     if (waitResult.status === "timeout") {
       log?.error?.(`[clawroom:executor] subagent timeout for task ${task.taskId}`);
-      ws.send({
+      client.send({
         type: "agent.fail",
         taskId: task.taskId,
         reason: "Agent execution timed out",
@@ -155,7 +155,7 @@ async function executeTask(opts: {
       .trim();
 
     log?.info?.(`[clawroom:executor] task ${task.taskId} completed${files.length > 0 ? ` (with ${files.length} file(s))` : ""}`);
-    ws.send({
+    client.send({
       type: "agent.complete",
       taskId: task.taskId,
       output,
@@ -169,7 +169,7 @@ async function executeTask(opts: {
   } catch (err) {
     const reason = err instanceof Error ? err.message : String(err);
     log?.error?.(`[clawroom:executor] unexpected error for task ${task.taskId}: ${reason}`);
-    ws.send({
+    client.send({
       type: "agent.release",
       taskId: task.taskId,
       reason,