@clawroom/openclaw 0.2.1 → 0.2.2

package/README.md

@@ -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 SSE + HTTP.
+3. Restart your gateway. The plugin connects to ClawRoom via HTTP polling.
 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.2.1",
+  "version": "0.2.2",
   "description": "OpenClaw channel plugin for the Claw Room task marketplace",
   "type": "module",
   "license": "MIT",
@@ -20,7 +20,7 @@
     "openclaw.plugin.json"
   ],
   "dependencies": {
-    "@clawroom/sdk": ">=0.0.1"
+    "@clawroom/sdk": "^0.2.2"
   },
   "peerDependencies": {
     "openclaw": "*"

package/src/channel.ts

@@ -169,10 +169,10 @@ export const clawroomPlugin: ChannelPlugin<ResolvedClawroomAccount> = {
         });
       };
 
-      // Wire up SSE events to OpenClaw health status
+      // Wire up HTTP polling events to OpenClaw health status
       client.onWelcome(() => publishConnected());
       client.onTask(() => {
-        // Any server message = update lastEventAt so gateway knows we're alive
+        // Any server task = update lastEventAt so gateway knows we're alive
         ctx.setStatus({
           accountId: account.accountId,
           running: true,
@@ -184,18 +184,6 @@ export const clawroomPlugin: ChannelPlugin<ResolvedClawroomAccount> = {
         });
       });
       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({
@@ -212,7 +200,7 @@ export const clawroomPlugin: ChannelPlugin<ResolvedClawroomAccount> = {
       client.connect();
       activeClient = client;
 
-      publishDisconnected("connecting...");
+      publishDisconnected("connecting via HTTP polling...");
 
       // Health check: if client somehow stopped, restart it.
       const healthCheck = setInterval(() => {

package/src/client.ts

@@ -1,23 +1,4 @@
-import type {
-  AgentMessage,
-  ServerClaimAck,
-  ServerMessage,
-  ServerTask,
-} from "@clawroom/sdk";
-
-// ── 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));
-}
+import type { AgentMessage, ServerClaimAck, ServerMessage, ServerTask } from "@clawroom/sdk";
 
 const HEARTBEAT_INTERVAL_MS = 30_000;
 const POLL_INTERVAL_MS = 10_000;
@@ -47,23 +28,16 @@ export type ClawroomClientOptions = {
 };
 
 /**
- * Claw Room agent client using SSE (server push) + HTTP (agent actions).
+ * Claw Room agent client using HTTP polling.
  *
- * 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)
- *
- * Agent→Server actions always use HTTP POST:
- *   /api/agents/heartbeat, /complete, /fail, /progress, /claim
+ * Agent→Server actions use HTTP POST:
+ *   /api/agents/heartbeat, /poll, /complete, /fail, /progress, /claim
  */
 export class ClawroomClient {
   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 connected = false;
   private httpBase: string;
 
   private taskCallbacks: TaskCallback[] = [];
@@ -77,9 +51,6 @@ export class ClawroomClient {
   private modeChangeCallbacks: ModeChangeCallback[] = [];
 
   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;
     if (ep.includes("/api/agents")) {
       this.httpBase = ep.replace(/\/stream\/?$/, "");
@@ -91,19 +62,16 @@ export class ClawroomClient {
 
   connect(): void {
     this.stopped = false;
-    this.reconnecting = false;
-    this.reconnectAttempt = 0;
-    this.consecutiveSseFails = 0;
-    this.mode = "sse";
-    this.doConnectSSE();
     this.startHeartbeat();
+    this.startPolling();
+    void this.register();
   }
 
   disconnect(): void {
     this.stopped = true;
     this.stopHeartbeat();
     this.stopPolling();
-    this.destroySSE();
+    this.markDisconnected();
   }
 
   send(message: AgentMessage): void {
@@ -113,12 +81,9 @@ export class ClawroomClient {
   }
 
   get isAlive(): boolean { return !this.stopped; }
-  get isConnected(): boolean {
-    if (this.mode === "polling") return true;
-    return this.sseAbort !== null && !this.sseAbort.signal.aborted;
-  }
+  get isConnected(): boolean { return this.connected; }
   get isFatal(): boolean { return false; }
-  get currentMode(): "sse" | "polling" { return this.mode; }
+  get currentMode(): "sse" | "polling" { return "polling"; }
 
   onTask(cb: TaskCallback): void { this.taskCallbacks.push(cb); }
   onTaskList(cb: TaskListCallback): void { this.taskListCallbacks.push(cb); }
@@ -136,7 +101,7 @@ export class ClawroomClient {
     this.stopHeartbeat();
     this.heartbeatTimer = setInterval(() => {
       if (this.stopped) return;
-      this.httpRequest("POST", "/heartbeat", {}).catch(() => {});
+      void this.register();
     }, HEARTBEAT_INTERVAL_MS);
   }
 
@@ -144,147 +109,61 @@ export class ClawroomClient {
     if (this.heartbeatTimer) { clearInterval(this.heartbeatTimer); this.heartbeatTimer = null; }
   }
 
-  // ── 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}`);
-      }
-
-      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
-        }
-      }
-
-      // 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");
-    });
-  }
-
-  private destroySSE(): void {
-    if (this.sseAbort) {
-      try { this.sseAbort.abort(); } catch {}
-      this.sseAbort = null;
-    }
-  }
-
-  private triggerReconnect(reason: string): void {
-    if (this.reconnecting || this.stopped) return;
-
-    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;
+  private markConnected(agentId?: string): void {
+    if (this.connected) return;
+    this.connected = true;
+    this.options.log?.info?.("[clawroom] polling connected");
+    for (const cb of this.modeChangeCallbacks) cb("polling");
+    if (agentId) {
+      for (const cb of this.welcomeCallbacks) cb(agentId);
     }
-
-    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.doConnectSSE();
-    }, delayMs);
   }
 
-  // ── Polling fallback ────────────────────────────────────────────
-
-  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.pollCycleCount = 0;
-    this.stopPolling();
-    this.pollTimer = setInterval(() => this.pollTick(), POLL_INTERVAL_MS);
+  private markDisconnected(): void {
+    if (!this.connected) return;
+    this.connected = false;
+    for (const cb of this.disconnectCallbacks) cb();
   }
 
-  private switchToSSE(): void {
-    this.options.log?.info?.("[clawroom] SSE restored, switching back from polling");
+  private startPolling(): void {
     this.stopPolling();
-    this.mode = "sse";
-    for (const cb of this.modeChangeCallbacks) cb("sse");
+    this.options.log?.info?.(`[clawroom] polling ${this.httpBase}/poll`);
+    this.pollTimer = setInterval(() => {
+      void this.pollTick();
+    }, POLL_INTERVAL_MS);
   }
 
   private stopPolling(): void {
     if (this.pollTimer) { clearInterval(this.pollTimer); this.pollTimer = null; }
   }
 
+  private async register(): Promise<void> {
+    try {
+      const res = await this.httpRequest("POST", "/heartbeat", {
+        deviceId: this.options.deviceId,
+        skills: this.options.skills,
+      });
+      this.markConnected(typeof res?.agentId === "string" ? res.agentId : undefined);
+    } catch (err) {
+      this.options.log?.warn?.(`[clawroom] heartbeat error: ${err}`);
+    }
+  }
+
   private async pollTick(): Promise<void> {
     if (this.stopped) return;
-    this.pollCycleCount++;
 
     try {
       const res = await this.httpRequest("POST", "/poll", {});
+      this.markConnected(typeof res?.agentId === "string" ? res.agentId : undefined);
       if (res.task) {
         const task = res.task as ServerTask;
-        this.options.log?.info?.(`[clawroom] [poll] received task ${task.taskId}: ${task.title}`);
+        this.options.log?.info?.(`[clawroom] 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}`);
-    }
-
-    // Try to restore SSE every 60s
-    if (this.pollCycleCount % 6 === 0) {
-      this.options.log?.info?.("[clawroom] [poll] attempting SSE restore...");
-      this.doConnectSSE();
+      this.options.log?.warn?.(`[clawroom] poll error: ${err}`);
+      this.markDisconnected();
     }
   }
 
@@ -338,45 +217,11 @@ export class ClawroomClient {
         this.stopped = true;
         this.stopHeartbeat();
         this.stopPolling();
-        this.destroySSE();
+        this.markDisconnected();
         for (const cb of this.fatalCallbacks) cb(`Unauthorized: ${text}`);
       }
       throw new Error(`HTTP ${res.status}: ${text}`);
     }
     return res.json();
   }
-
-  // ── Message handling ──────────────────────────────────────────────
-
-  private handleMessage(raw: string): void {
-    let msg: ServerMessage;
-    try { msg = JSON.parse(raw) as ServerMessage; } catch { return; }
-
-    switch (msg.type) {
-      case "server.welcome":
-        this.options.log?.info?.(`[clawroom] welcome, agentId=${msg.agentId}`);
-        for (const cb of this.welcomeCallbacks) cb(msg.agentId);
-        break;
-      case "server.pong":
-        break;
-      case "server.task":
-        this.options.log?.info?.(`[clawroom] received task ${msg.taskId}: ${msg.title}`);
-        for (const cb of this.taskCallbacks) cb(msg);
-        break;
-      case "server.task_list":
-        this.options.log?.info?.(`[clawroom] received ${msg.tasks.length} open task(s)`);
-        for (const cb of this.taskListCallbacks) cb(msg.tasks);
-        break;
-      case "server.claim_ack":
-        this.options.log?.info?.(`[clawroom] claim_ack taskId=${msg.taskId} ok=${msg.ok}${msg.reason ? ` reason=${msg.reason}` : ""}`);
-        for (const cb of this.claimAckCallbacks) cb(msg);
-        break;
-      case "server.error":
-        this.options.log?.error?.(`[clawroom] server error: ${msg.message}`);
-        for (const cb of this.errorCallbacks) cb(msg);
-        break;
-      default:
-        this.options.log?.warn?.("[clawroom] unknown message type", msg);
-    }
-  }
 }

package/src/task-executor.ts

@@ -12,10 +12,11 @@ const MAX_FILE_SIZE = 10 * 1024 * 1024;
 
 /**
  * Wire up the task execution pipeline:
- *   1. On server.task / server.task_list -> store as available (no auto-claim)
+ *   1. On server.task / server.task_list -> store as available
  *   2. On claim_ack(ok) -> invoke subagent -> send result/fail
  *
- * Claiming is triggered externally (by the owner via Dashboard).
+ * Tasks arrive through the polling client, either because the agent auto-claimed
+ * them or because the owner manually claimed them from the dashboard.
  */
 export function setupTaskExecutor(opts: {
   client: ClawroomClient;
@@ -28,8 +29,9 @@ export function setupTaskExecutor(opts: {
 }): void {
   const { client, runtime, log } = opts;
 
-  // Track received tasks (from broadcast or server push after claim)
+  // Track received tasks until they transition into an active execution.
   const knownTasks = new Map<string, ServerTask>();
+  const activeTasks = new Set<string>();
 
   // New task received — store it for potential execution
   client.onTask((task: ServerTask) => {
@@ -59,6 +61,11 @@ export function setupTaskExecutor(opts: {
     const task = knownTasks.get(ack.taskId);
     knownTasks.delete(ack.taskId);
 
+    if (activeTasks.has(ack.taskId)) {
+      log?.info?.(`[clawroom:executor] task ${ack.taskId} is already running, ignoring duplicate dispatch`);
+      return;
+    }
+
     if (!task) {
       log?.warn?.(
         `[clawroom:executor] claim_ack for unknown task ${ack.taskId}`,
@@ -67,7 +74,10 @@ export function setupTaskExecutor(opts: {
     }
 
     log?.info?.(`[clawroom:executor] executing task ${task.taskId}`);
-    void executeTask({ client, runtime, task, log });
+    activeTasks.add(task.taskId);
+    void executeTask({ client, runtime, task, log }).finally(() => {
+      activeTasks.delete(task.taskId);
+    });
   });
 }