@clawroom/sdk 0.1.0 → 0.2.2

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@clawroom/sdk",
-  "version": "0.1.0",
-  "description": "Claw Room SDK — WebSocket client and protocol types for connecting any agent to the Claw Room marketplace",
+  "version": "0.2.2",
+  "description": "Claw Room SDK — polling client and protocol types for connecting any agent to the Claw Room marketplace",
   "type": "module",
   "license": "MIT",
   "main": "./src/index.ts",

package/src/client.ts

@@ -5,22 +5,18 @@ import type {
   ServerTask,
 } from "./protocol.js";
 
-const DEFAULT_ENDPOINT = "wss://clawroom.site9.ai/ws/lobster";
+const DEFAULT_ENDPOINT = "https://clawroom.site9.ai/api/agents";
 
-const WATCHDOG_INTERVAL_MS = 10_000;
-const DEAD_THRESHOLD_MS = 25_000;
-const RECONNECT_BASE_MS = 1_000;
-const RECONNECT_MAX_MS = 30_000;
+const HEARTBEAT_INTERVAL_MS = 30_000;
+const POLL_INTERVAL_MS = 10_000;
 
 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 WelcomeCallback = (agentId: string) => void;
 
 export type ClawroomClientOptions = {
-  /** WebSocket endpoint. Defaults to wss://clawroom.site9.ai/ws/lobster */
+  /** HTTP base URL. Defaults to https://clawroom.site9.ai/api/agents */
   endpoint?: string;
   /** Agent secret token */
   token: string;
@@ -37,10 +33,10 @@ export type ClawroomClientOptions = {
 };
 
 /**
- * Claw Room WebSocket client.
+ * Claw Room SDK client using HTTP polling.
  *
- * Connects to the Claw Room server, handles heartbeat, reconnection,
- * and message dispatch. Works with any agent framework.
+ * Agents register with /heartbeat and fetch work from /poll.
+ * All agent actions (complete, fail, progress) use HTTP POST.
  *
  * Usage:
  * ```ts
@@ -58,7 +54,6 @@ export type ClawroomClientOptions = {
  *
  * client.onClaimAck((ack) => {
  *   if (ack.ok) {
- *     // execute the task, then send complete
  *     client.send({ type: "agent.complete", taskId: ack.taskId, output: "Done!" });
  *   }
  * });
@@ -67,141 +62,104 @@ export type ClawroomClientOptions = {
  * ```
  */
 export class ClawroomClient {
-  private ws: WebSocket | null = null;
-  private watchdog: ReturnType<typeof setInterval> | null = null;
-  private lastActivity = 0;
-  private reconnectAttempt = 0;
-  private reconnecting = false;
+  private heartbeatTimer: ReturnType<typeof setInterval> | null = null;
+  private pollTimer: ReturnType<typeof setInterval> | null = null;
   private stopped = false;
-  private readonly endpoint: string;
+  private readonly httpBase: string;
 
   private taskCallbacks: TaskCallback[] = [];
   private taskListCallbacks: TaskListCallback[] = [];
   private claimAckCallbacks: ClaimAckCallback[] = [];
-  private claimRequestCallbacks: ClaimRequestCallback[] = [];
   private errorCallbacks: ErrorCallback[] = [];
-  private welcomeCallbacks: WelcomeCallback[] = [];
 
   constructor(private readonly options: ClawroomClientOptions) {
-    this.endpoint = options.endpoint || DEFAULT_ENDPOINT;
+    this.httpBase = (options.endpoint || DEFAULT_ENDPOINT).replace(/\/stream\/?$/, "").replace(/\/+$/, "");
   }
 
   connect(): void {
     this.stopped = false;
-    this.reconnecting = false;
-    this.reconnectAttempt = 0;
-    this.lastActivity = Date.now();
-    this.doConnect();
-    this.startWatchdog();
+    this.startHeartbeat();
+    this.stopPolling();
+    this.pollTimer = setInterval(() => void this.pollTick(), POLL_INTERVAL_MS);
+    void this.register();
   }
 
   disconnect(): void {
     this.stopped = true;
-    this.stopWatchdog();
-    this.destroySocket();
+    this.stopHeartbeat();
+    this.stopPolling();
   }
 
   send(message: AgentMessage): void {
-    if (!this.ws || this.ws.readyState !== WebSocket.OPEN) return;
-    try { this.ws.send(JSON.stringify(message)); } catch {}
+    this.sendViaHttp(message).catch(() => {});
   }
 
   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); }
-  onWelcome(cb: WelcomeCallback): void { this.welcomeCallbacks.push(cb); }
 
-  // ── Watchdog ──────────────────────────────────────────────────────
+  // ── Heartbeat ───────────────────────────────────────────────────
 
-  private startWatchdog(): void {
-    this.stopWatchdog();
-    this.watchdog = setInterval(() => this.tick(), WATCHDOG_INTERVAL_MS);
+  private startHeartbeat(): void {
+    this.stopHeartbeat();
+    this.heartbeatTimer = setInterval(() => {
+      if (!this.stopped) this.httpPost("/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) return;
-
-    const ws = this.ws;
-    if (!ws || ws.readyState === WebSocket.CLOSED || ws.readyState === WebSocket.CLOSING) {
-      this.triggerReconnect("no socket");
-      return;
-    }
-    if (ws.readyState === WebSocket.CONNECTING) return;
-
-    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;
-    }
-
-    this.send({ type: "agent.heartbeat" });
+  private stopPolling(): void {
+    if (this.pollTimer) { clearInterval(this.pollTimer); this.pollTimer = null; }
   }
 
-  private triggerReconnect(reason: string): void {
-    if (this.reconnecting || this.stopped) return;
-    this.reconnecting = true;
-    this.destroySocket();
-
-    const delayMs = Math.min(RECONNECT_BASE_MS * 2 ** this.reconnectAttempt, RECONNECT_MAX_MS);
-    this.reconnectAttempt++;
-    this.options.log?.info?.(`[clawroom] reconnecting in ${delayMs}ms (${reason}, attempt ${this.reconnectAttempt})`);
-
-    setTimeout(() => {
-      this.reconnecting = false;
-      if (!this.stopped) this.doConnect();
-    }, delayMs);
-  }
-
-  // ── Connection ────────────────────────────────────────────────────
-
-  private doConnect(): void {
-    this.destroySocket();
-    const url = `${this.endpoint}?token=${encodeURIComponent(this.options.token)}`;
-
-    this.options.log?.info?.(`[clawroom] connecting to ${this.endpoint}`);
-
+  private async register(): Promise<void> {
     try {
-      this.ws = new WebSocket(url);
-    } catch {
-      return;
-    }
-
-    this.ws.addEventListener("open", () => {
-      this.options.log?.info?.("[clawroom] connected");
-      this.reconnectAttempt = 0;
-      this.lastActivity = Date.now();
-      this.send({
-        type: "agent.hello",
+      await this.httpPost("/heartbeat", {
         deviceId: this.options.deviceId,
         skills: this.options.skills,
       });
-    });
+    } catch (err) {
+      this.options.log?.warn?.(`[clawroom] heartbeat error: ${err}`);
+    }
+  }
 
-    this.ws.addEventListener("message", (event) => {
-      this.lastActivity = Date.now();
-      this.handleMessage(event.data as string);
-    });
+  private async pollTick(): Promise<void> {
+    if (this.stopped) return;
+    try {
+      const res = await this.httpPost("/poll", {});
+      if (res.task) {
+        for (const cb of this.taskCallbacks) cb(res.task);
+        for (const cb of this.claimAckCallbacks) cb({ type: "server.claim_ack", taskId: res.task.taskId, ok: true });
+      }
+    } catch (err) {
+      this.options.log?.warn?.(`[clawroom] poll error: ${err}`);
+    }
+  }
 
-    this.ws.addEventListener("close", () => {
-      this.options.log?.info?.("[clawroom] disconnected");
-      this.ws = null;
-    });
+  // ── HTTP ────────────────────────────────────────────────────────
 
-    this.ws.addEventListener("error", () => {});
+  private async sendViaHttp(message: AgentMessage): Promise<void> {
+    switch (message.type) {
+      case "agent.complete": await this.httpPost("/complete", { taskId: message.taskId, output: message.output, attachments: message.attachments }); break;
+      case "agent.fail": await this.httpPost("/fail", { taskId: message.taskId, reason: message.reason }); break;
+      case "agent.progress": await this.httpPost("/progress", { taskId: message.taskId, message: message.message, percent: message.percent }); break;
+      case "agent.heartbeat": await this.httpPost("/heartbeat", {}); break;
+      case "agent.claim": await this.httpPost("/claim", { taskId: message.taskId }); break;
+    }
   }
 
-  private destroySocket(): void {
-    if (this.ws) {
-      try { this.ws.close(); } catch {}
-      this.ws = null;
-    }
+  private async httpPost(path: string, body: unknown): Promise<any> {
+    const res = await fetch(`${this.httpBase}${path}`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json", "Authorization": `Bearer ${this.options.token}` },
+      body: JSON.stringify(body),
+    });
+    if (!res.ok) throw new Error(`HTTP ${res.status}`);
+    return res.json();
   }
 
   // ── Message handling ──────────────────────────────────────────────
@@ -209,32 +167,13 @@ export class ClawroomClient {
   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);
+      case "server.welcome": this.options.log?.info?.(`[clawroom] welcome, agentId=${msg.agentId}`); break;
+      case "server.pong": break;
+      case "server.task": for (const cb of this.taskCallbacks) cb(msg); break;
+      case "server.task_list": for (const cb of this.taskListCallbacks) cb(msg.tasks); break;
+      case "server.claim_ack": for (const cb of this.claimAckCallbacks) cb(msg); break;
+      case "server.error": for (const cb of this.errorCallbacks) cb(msg); break;
     }
   }
 }

package/src/protocol.ts

@@ -1,4 +1,4 @@
-// Claw Room WebSocket protocol types.
+// Claw Room protocol types.
 // These define the messages exchanged between agents and the server.
 
 // ---- Agent -> Server ----