@clawroom/openclaw 0.2.1 → 0.2.3

package/README.md

@@ -1,4 +1,4 @@
-# clawroom
+# ClawRoom
 
 OpenClaw channel plugin for the ClawRoom task marketplace. Connects your OpenClaw gateway to ClawRoom so your lobsters can claim and execute tasks.
 
@@ -23,16 +23,16 @@ 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
 
-The repository includes a GitHub Actions workflow that publishes this package to npm through npm Trusted Publisher when a tag matching the plugin version is pushed.
+The repository includes a GitHub Actions workflow that publishes `@clawroom/protocol`, `@clawroom/sdk`, and `@clawroom/openclaw` to npm when a release tag is pushed.
 
 To publish a new version:
 
-1. Update `plugin/package.json` with the new version.
-2. Push the matching tag, for example `git tag 0.0.13 && git push origin 0.0.13`.
-
-The npm package must have a Trusted Publisher configured for this GitHub repository with the workflow filename `release-plugin.yml`. npm treats the repository, workflow name, and other Trusted Publisher fields as case-sensitive.
+1. Update the package versions in `protocol/package.json`, `sdk/package.json`, and `plugin/package.json`.
+2. Commit and push the release commit to GitHub.
+3. Push a release tag, for example `git tag plugin-0.2.3 && git push origin plugin-0.2.3`.
+4. Watch `.github/workflows/release-plugin.yml` until all three publish jobs succeed.

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@clawroom/openclaw",
-  "version": "0.2.1",
-  "description": "OpenClaw channel plugin for the Claw Room task marketplace",
+  "version": "0.2.3",
+  "description": "OpenClaw channel plugin for the ClawRoom task marketplace",
   "type": "module",
   "license": "MIT",
   "repository": {
@@ -20,7 +20,7 @@
     "openclaw.plugin.json"
   ],
   "dependencies": {
-    "@clawroom/sdk": ">=0.0.1"
+    "@clawroom/sdk": "^0.2.3"
   },
   "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(() => {
@@ -280,7 +268,7 @@ export const clawroomPlugin: ChannelPlugin<ResolvedClawroomAccount> = {
  * runtime environment when available, falling back to a random id.
  */
 function resolveDeviceId(ctx: {
-  runtime: { hostname?: string; machineId?: string };
+  runtime?: unknown;
 }): string {
   // The RuntimeEnv may expose hostname or machineId depending on version
   const r = ctx.runtime as Record<string, unknown>;

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, ServerTask } from "@clawroom/sdk";
 
 const HEARTBEAT_INTERVAL_MS = 30_000;
 const POLL_INTERVAL_MS = 10_000;
@@ -25,14 +6,10 @@ 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;
+type FatalCallback = (reason: string, code?: number) => void;
 
 export type ClawroomClientOptions = {
   endpoint: string;
@@ -40,70 +17,47 @@ export type ClawroomClientOptions = {
   deviceId: string;
   skills: string[];
   log?: {
-    info?: (...args: unknown[]) => void;
-    warn?: (...args: unknown[]) => void;
-    error?: (...args: unknown[]) => void;
+    info?: (message: string, ...args: unknown[]) => void;
+    warn?: (message: string, ...args: unknown[]) => void;
+    error?: (message: string, ...args: unknown[]) => void;
   };
 };
 
 /**
- * Claw Room agent client using SSE (server push) + HTTP (agent actions).
+ * ClawRoom 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[] = [];
-  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) {
-    // 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\/?$/, "");
-    } else {
-      const httpUrl = ep.replace(/^wss:/, "https:").replace(/^ws:/, "http:");
-      this.httpBase = httpUrl.replace(/\/ws\/.*$/, "/api/agents");
-    }
+    this.httpBase = options.endpoint.replace(/\/+$/, "");
   }
 
   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,30 +67,22 @@ 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; }
 
   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) ───────────────────────────
+  // ── Heartbeat (HTTP POST) ───────────────────────────────────────
 
   private startHeartbeat(): void {
     this.stopHeartbeat();
     this.heartbeatTimer = setInterval(() => {
       if (this.stopped) return;
-      this.httpRequest("POST", "/heartbeat", {}).catch(() => {});
+      void this.register();
     }, HEARTBEAT_INTERVAL_MS);
   }
 
@@ -144,147 +90,60 @@ 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");
+    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 +197,11 @@ export class ClawroomClient {
         this.stopped = true;
         this.stopHeartbeat();
         this.stopPolling();
-        this.destroySSE();
-        for (const cb of this.fatalCallbacks) cb(`Unauthorized: ${text}`);
+        this.markDisconnected();
+        for (const cb of this.fatalCallbacks) cb(`Unauthorized: ${text}`, 401);
       }
       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,24 +12,26 @@ 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 -> 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;
   runtime: PluginRuntime;
   log?: {
-    info?: (...args: unknown[]) => void;
-    warn?: (...args: unknown[]) => void;
-    error?: (...args: unknown[]) => void;
+    info?: (message: string, ...args: unknown[]) => void;
+    warn?: (message: string, ...args: unknown[]) => void;
+    error?: (message: string, ...args: unknown[]) => void;
   };
 }): 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) => {
@@ -37,15 +39,6 @@ export function setupTaskExecutor(opts: {
     knownTasks.set(task.taskId, task);
   });
 
-  // Task list on connect — store all
-  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}`);
-      knownTasks.set(t.taskId, t);
-    }
-  });
-
   // Claim ack — either from plugin-initiated claim or Dashboard-initiated claim
   client.onClaimAck((ack: ServerClaimAck) => {
     if (!ack.ok) {
@@ -59,6 +52,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 +65,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);
+    });
   });
 }
 
@@ -80,8 +81,8 @@ async function executeTask(opts: {
   runtime: PluginRuntime;
   task: ServerTask;
   log?: {
-    info?: (...args: unknown[]) => void;
-    error?: (...args: unknown[]) => void;
+    info?: (message: string, ...args: unknown[]) => void;
+    error?: (message: string, ...args: unknown[]) => void;
   };
 }): Promise<void> {
   const { client, runtime, task, log } = opts;
@@ -97,7 +98,7 @@ async function executeTask(opts: {
       idempotencyKey: `clawroom:${task.taskId}`,
       message: agentMessage,
       extraSystemPrompt:
-        "You are executing a task from the Claw Room marketplace. " +
+        "You are executing a task from the ClawRoom marketplace. " +
         "Complete the task and provide a SHORT summary (2-3 sentences) of what you did. " +
         "Do NOT include any local file paths, machine info, or internal details in your summary. " +
         "If you create output files, list their absolute paths at the very end, " +
@@ -170,7 +171,7 @@ async function executeTask(opts: {
     const reason = err instanceof Error ? err.message : String(err);
     log?.error?.(`[clawroom:executor] unexpected error for task ${task.taskId}: ${reason}`);
     client.send({
-      type: "agent.release",
+      type: "agent.fail",
       taskId: task.taskId,
       reason,
     });
@@ -279,7 +280,10 @@ function tryParse(s: string): unknown {
  */
 function readAllFiles(
   paths: string[],
-  log?: { info?: (...args: unknown[]) => void; warn?: (...args: unknown[]) => void },
+  log?: {
+    info?: (message: string, ...args: unknown[]) => void;
+    warn?: (message: string, ...args: unknown[]) => void;
+  },
 ): AgentResultFile[] {
   const results: AgentResultFile[] = [];
   for (const fp of paths) {