@clawroom/openclaw 0.2.0 → 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.0",
+  "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

@@ -2,7 +2,7 @@ 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 ────────────────────────────────────────────────
@@ -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,10 +169,10 @@ export const clawroomPlugin: ChannelPlugin<ResolvedClawroomAccount> = {
         });
       };
 
-      // Wire up WS 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({
@@ -208,11 +196,11 @@ export const clawroomPlugin: ChannelPlugin<ResolvedClawroomAccount> = {
         });
       });
 
-      setupTaskExecutor({ ws: client, runtime, log });
+      setupTaskExecutor({ client: client, runtime, log });
       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

@@ -0,0 +1,227 @@
+import type { AgentMessage, ServerClaimAck, ServerMessage, ServerTask } from "@clawroom/sdk";
+
+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 ClawroomClientOptions = {
+  endpoint: string;
+  token: string;
+  deviceId: string;
+  skills: string[];
+  log?: {
+    info?: (...args: unknown[]) => void;
+    warn?: (...args: unknown[]) => void;
+    error?: (...args: unknown[]) => void;
+  };
+};
+
+/**
+ * Claw Room agent client using HTTP polling.
+ *
+ * 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 stopped = false;
+  private connected = false;
+  private httpBase: string;
+
+  private taskCallbacks: TaskCallback[] = [];
+  private taskListCallbacks: TaskListCallback[] = [];
+  private claimAckCallbacks: ClaimAckCallback[] = [];
+  private claimRequestCallbacks: ClaimRequestCallback[] = [];
+  private errorCallbacks: ErrorCallback[] = [];
+  private disconnectCallbacks: DisconnectCallback[] = [];
+  private welcomeCallbacks: WelcomeCallback[] = [];
+  private fatalCallbacks: FatalCallback[] = [];
+  private modeChangeCallbacks: ModeChangeCallback[] = [];
+
+  constructor(private readonly options: ClawroomClientOptions) {
+    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.startHeartbeat();
+    this.startPolling();
+    void this.register();
+  }
+
+  disconnect(): void {
+    this.stopped = true;
+    this.stopHeartbeat();
+    this.stopPolling();
+    this.markDisconnected();
+  }
+
+  send(message: AgentMessage): void {
+    this.sendViaHttp(message).catch((err) => {
+      this.options.log?.warn?.(`[clawroom] send error: ${err}`);
+    });
+  }
+
+  get isAlive(): boolean { return !this.stopped; }
+  get isConnected(): boolean { return this.connected; }
+  get isFatal(): boolean { return false; }
+  get currentMode(): "sse" | "polling" { return "polling"; }
+
+  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); }
+
+  // ── Heartbeat (HTTP POST, both modes) ───────────────────────────
+
+  private startHeartbeat(): void {
+    this.stopHeartbeat();
+    this.heartbeatTimer = setInterval(() => {
+      if (this.stopped) return;
+      void this.register();
+    }, HEARTBEAT_INTERVAL_MS);
+  }
+
+  private stopHeartbeat(): void {
+    if (this.heartbeatTimer) { clearInterval(this.heartbeatTimer); this.heartbeatTimer = null; }
+  }
+
+  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);
+    }
+  }
+
+  private markDisconnected(): void {
+    if (!this.connected) return;
+    this.connected = false;
+    for (const cb of this.disconnectCallbacks) cb();
+  }
+
+  private startPolling(): void {
+    this.stopPolling();
+    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;
+
+    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] 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.markDisconnected();
+    }
+  }
+
+  // ── HTTP send ───────────────────────────────────────────────────
+
+  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 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.markDisconnected();
+        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";
 
@@ -12,13 +12,14 @@ 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: {
-  ws: ClawroomWsClient;
+  client: ClawroomClient;
   runtime: PluginRuntime;
   log?: {
     info?: (...args: unknown[]) => void;
@@ -26,19 +27,20 @@ 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)
+  // 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
-  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 +49,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"}`,
@@ -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({ ws, runtime, task, log });
+    activeTasks.add(task.taskId);
+    void executeTask({ client, runtime, task, log }).finally(() => {
+      activeTasks.delete(task.taskId);
+    });
   });
 }
 
@@ -76,7 +86,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 +94,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 +126,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 +136,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 +165,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 +179,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,

package/src/ws-client.ts

@@ -1,359 +0,0 @@
-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));
-}
-
-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;
-  token: string;
-  deviceId: string;
-  skills: string[];
-  log?: {
-    info?: (...args: unknown[]) => void;
-    warn?: (...args: unknown[]) => void;
-    error?: (...args: unknown[]) => void;
-  };
-};
-
-/**
- * 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)
- *
- * Agent→Server actions always use HTTP POST:
- *   /api/agents/heartbeat, /complete, /fail, /progress, /claim
- */
-export class ClawroomWsClient {
-  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[] = [];
-  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.consecutiveSseFails = 0;
-    this.mode = "sse";
-    this.doConnectSSE();
-    this.startHeartbeat();
-  }
-
-  disconnect(): void {
-    this.stopped = true;
-    this.stopHeartbeat();
-    this.stopPolling();
-    this.destroySSE();
-  }
-
-  send(message: AgentMessage): void {
-    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); }
-
-  // ── Heartbeat (HTTP POST, both modes) ───────────────────────────
-
-  private startHeartbeat(): void {
-    this.stopHeartbeat();
-    this.heartbeatTimer = setInterval(() => {
-      if (this.stopped) return;
-      this.httpRequest("POST", "/heartbeat", {}).catch(() => {});
-    }, HEARTBEAT_INTERVAL_MS);
-  }
-
-  private stopHeartbeat(): void {
-    if (this.heartbeatTimer) { clearInterval(this.heartbeatTimer); this.heartbeatTimer = null; }
-  }
-
-  // ── 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}`;
-
-    this.options.log?.info?.(`[clawroom] SSE connecting to ${this.httpBase}/stream`);
-
-    try {
-      this.eventSource = new EventSource(url);
-    } catch {
-      this.triggerReconnect("EventSource creation failed");
-      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");
-    };
-  }
-
-  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;
-
-    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.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 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 {
-      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}`);
-    }
-
-    // Try to restore SSE every 60s
-    if (this.pollCycleCount % 6 === 0) {
-      this.options.log?.info?.("[clawroom] [poll] attempting SSE restore...");
-      this.doConnectSSE();
-    }
-  }
-
-  // ── HTTP send ───────────────────────────────────────────────────
-
-  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 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 ──────────────────────────────────────────────
-
-  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);
-    }
-  }
-}