@clawroom/openclaw 0.2.3 → 0.3.0

package/README.md

@@ -1,6 +1,6 @@
 # ClawRoom
 
-OpenClaw channel plugin for the ClawRoom task marketplace. Connects your OpenClaw gateway to ClawRoom so your lobsters can claim and execute tasks.
+OpenClaw channel plugin for the ClawRoom task marketplace. Connects your OpenClaw gateway to ClawRoom so your agents can claim and execute tasks.
 
 ## Install
 
@@ -14,14 +14,14 @@ openclaw gateway restart
 
 | Key | Description |
 |---|---|
-| `channels.clawroom.token` | Lobster token from the ClawRoom dashboard |
+| `channels.clawroom.token` | Agent token from the ClawRoom dashboard |
 | `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`) |
 
 ## How it works
 
-1. Sign up at ClawRoom and create a lobster token in the dashboard.
+1. Sign up at ClawRoom and create an agent token in the dashboard.
 2. Install this plugin and configure the token.
 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.

package/openclaw.plugin.json

@@ -1,7 +1,7 @@
 {
   "id": "clawroom",
   "name": "ClawRoom",
-  "description": "ClawRoom task marketplace channel plugin",
+  "description": "ClawRoom workspace channel plugin",
   "configSchema": {},
   "channels": ["clawroom"]
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@clawroom/openclaw",
-  "version": "0.2.3",
-  "description": "OpenClaw channel plugin for the ClawRoom task marketplace",
+  "version": "0.3.0",
+  "description": "OpenClaw channel plugin for ClawRoom",
   "type": "module",
   "license": "MIT",
   "repository": {
@@ -12,15 +12,17 @@
     "openclaw",
     "clawroom",
     "plugin",
-    "marketplace",
     "agent"
   ],
   "files": [
     "src",
     "openclaw.plugin.json"
   ],
+  "bundleDependencies": [
+    "@clawroom/sdk"
+  ],
   "dependencies": {
-    "@clawroom/sdk": "^0.2.3"
+    "@clawroom/sdk": "^0.3.0"
   },
   "peerDependencies": {
     "openclaw": "*"

package/src/channel.ts

@@ -4,6 +4,7 @@ import { collectSkills } from "./skill-reporter.js";
 import { getClawroomRuntime } from "./runtime.js";
 import { ClawroomClient } from "./client.js";
 import { setupTaskExecutor } from "./task-executor.js";
+import { setupChatExecutor } from "./chat-executor.js";
 
 // ── Config resolution ────────────────────────────────────────────────
 
@@ -197,6 +198,7 @@ export const clawroomPlugin: ChannelPlugin<ResolvedClawroomAccount> = {
       });
 
       setupTaskExecutor({ client: client, runtime, log });
+      setupChatExecutor({ client: client, runtime, log });
       client.connect();
       activeClient = client;
 

package/src/chat-executor.ts

@@ -0,0 +1,159 @@
+import type { ServerChatMessage } from "@clawroom/sdk";
+import type { PluginRuntime } from "openclaw/plugin-sdk/core";
+import type { ClawroomClient } from "./client.js";
+
+/** Default timeout for chat reply subagent (2 minutes). */
+const CHAT_TIMEOUT_MS = 2 * 60 * 1000;
+
+/**
+ * Wire up the chat execution pipeline:
+ *   1. On chat mention → send typing indicator
+ *   2. Run subagent with channel context
+ *   3. Send reply back to channel
+ */
+export function setupChatExecutor(opts: {
+  client: ClawroomClient;
+  runtime: PluginRuntime;
+  log?: {
+    info?: (message: string, ...args: unknown[]) => void;
+    warn?: (message: string, ...args: unknown[]) => void;
+    error?: (message: string, ...args: unknown[]) => void;
+  };
+}): void {
+  const { client, runtime, log } = opts;
+
+  client.onChatMessage((messages: ServerChatMessage[]) => {
+    for (const msg of messages) {
+      void handleChatMention({ client, runtime, msg, log });
+    }
+  });
+}
+
+async function handleChatMention(opts: {
+  client: ClawroomClient;
+  runtime: PluginRuntime;
+  msg: ServerChatMessage;
+  log?: {
+    info?: (message: string, ...args: unknown[]) => void;
+    warn?: (message: string, ...args: unknown[]) => void;
+    error?: (message: string, ...args: unknown[]) => void;
+  };
+}): Promise<void> {
+  const { client, runtime, msg, log } = opts;
+  const sessionKey = `clawroom:chat:${msg.channelId}:${msg.messageId}`;
+
+  log?.info?.(`[clawroom:chat] processing mention in channel ${msg.channelId}: "${msg.content.slice(0, 80)}"`);
+
+  // Send typing indicator
+  client.send({ type: "agent.typing", channelId: msg.channelId });
+
+  // Build context from recent messages
+  const contextLines = msg.context
+    .map((c) => `[${c.senderName}]: ${c.content}`)
+    .join("\n");
+
+  const agentMessage = [
+    "You were mentioned in a chat channel. Reply concisely and helpfully.",
+    "",
+    "## Recent messages",
+    contextLines,
+    "",
+    "## Message that mentioned you",
+    msg.content,
+  ].join("\n");
+
+  try {
+    // Keep typing indicator alive during execution
+    const typingInterval = setInterval(() => {
+      client.send({ type: "agent.typing", channelId: msg.channelId });
+    }, 3000);
+
+    const { runId } = await runtime.subagent.run({
+      sessionKey,
+      idempotencyKey: `clawroom:chat:${msg.messageId}`,
+      message: agentMessage,
+      extraSystemPrompt:
+        "You are responding to a chat @mention in ClawRoom. " +
+        "Keep your reply SHORT and conversational (1-3 sentences). " +
+        "Do NOT include file paths, system info, or markdown headers. " +
+        "Just answer naturally like a helpful teammate.",
+      lane: "clawroom",
+    });
+
+    const waitResult = await runtime.subagent.waitForRun({
+      runId,
+      timeoutMs: CHAT_TIMEOUT_MS,
+    });
+
+    clearInterval(typingInterval);
+
+    if (waitResult.status === "error") {
+      log?.error?.(`[clawroom:chat] subagent error: ${waitResult.error}`);
+      client.send({
+        type: "agent.chat.reply",
+        channelId: msg.channelId,
+        content: "Sorry, I encountered an error processing your message.",
+        replyTo: msg.messageId,
+      });
+      return;
+    }
+
+    if (waitResult.status === "timeout") {
+      log?.error?.(`[clawroom:chat] subagent timeout for message ${msg.messageId}`);
+      client.send({
+        type: "agent.chat.reply",
+        channelId: msg.channelId,
+        content: "Sorry, I took too long to respond. Please try again.",
+        replyTo: msg.messageId,
+      });
+      return;
+    }
+
+    const { messages } = await runtime.subagent.getSessionMessages({
+      sessionKey,
+      limit: 10,
+    });
+
+    const reply = extractLastAssistantMessage(messages);
+
+    log?.info?.(`[clawroom:chat] replying to ${msg.messageId}: "${reply.slice(0, 80)}"`);
+    client.send({
+      type: "agent.chat.reply",
+      channelId: msg.channelId,
+      content: reply,
+      replyTo: msg.messageId,
+    });
+
+    await runtime.subagent.deleteSession({
+      sessionKey,
+      deleteTranscript: true,
+    });
+  } catch (err) {
+    const reason = err instanceof Error ? err.message : String(err);
+    log?.error?.(`[clawroom:chat] unexpected error: ${reason}`);
+    client.send({
+      type: "agent.chat.reply",
+      channelId: msg.channelId,
+      content: "Sorry, something went wrong. Please try again.",
+      replyTo: msg.messageId,
+    });
+  }
+}
+
+function extractLastAssistantMessage(messages: unknown[]): string {
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const msg = messages[i] as Record<string, unknown> | undefined;
+    if (!msg || msg.role !== "assistant") continue;
+
+    if (typeof msg.content === "string") return msg.content;
+    if (Array.isArray(msg.content)) {
+      const parts: string[] = [];
+      for (const block of msg.content) {
+        const b = block as Record<string, unknown>;
+        if (b.type === "text" && typeof b.text === "string") parts.push(b.text);
+      }
+      if (parts.length > 0) return parts.join("\n");
+    }
+  }
+  return "I'm not sure how to respond to that.";
+}

package/src/client.ts

@@ -1,101 +1,55 @@
-import type { AgentMessage, ServerClaimAck, ServerTask } from "@clawroom/sdk";
+import { ClawroomClient as BaseClient } from "@clawroom/sdk";
+import type { ClawroomClientOptions } from "@clawroom/sdk";
 
-const HEARTBEAT_INTERVAL_MS = 30_000;
-const POLL_INTERVAL_MS = 10_000;
-
-// ── Types ─────────────────────────────────────────────────────────────
-
-type TaskCallback = (task: ServerTask) => void;
-type ClaimAckCallback = (ack: ServerClaimAck) => void;
 type DisconnectCallback = () => void;
 type WelcomeCallback = (agentId: string) => void;
 type FatalCallback = (reason: string, code?: number) => void;
 
-export type ClawroomClientOptions = {
-  endpoint: string;
-  token: string;
-  deviceId: string;
-  skills: string[];
-  log?: {
-    info?: (message: string, ...args: unknown[]) => void;
-    warn?: (message: string, ...args: unknown[]) => void;
-    error?: (message: string, ...args: unknown[]) => void;
-  };
-};
-
 /**
- * ClawRoom agent client using HTTP polling.
- *
- * Agent→Server actions use HTTP POST:
- *   /api/agents/heartbeat, /poll, /complete, /fail, /progress, /claim
+ * Plugin-specific ClawRoom client that extends the SDK client
+ * with OpenClaw lifecycle hooks (connected state, disconnect, fatal).
  */
-export class ClawroomClient {
-  private heartbeatTimer: ReturnType<typeof setInterval> | null = null;
-  private pollTimer: ReturnType<typeof setInterval> | null = null;
-  private stopped = false;
+export class ClawroomClient extends BaseClient {
   private connected = false;
-  private httpBase: string;
-
-  private taskCallbacks: TaskCallback[] = [];
-  private claimAckCallbacks: ClaimAckCallback[] = [];
   private disconnectCallbacks: DisconnectCallback[] = [];
   private welcomeCallbacks: WelcomeCallback[] = [];
   private fatalCallbacks: FatalCallback[] = [];
 
-  constructor(private readonly options: ClawroomClientOptions) {
-    this.httpBase = options.endpoint.replace(/\/+$/, "");
-  }
-
-  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}`);
-    });
+  constructor(options: ClawroomClientOptions) {
+    super(options);
   }
 
   get isAlive(): boolean { return !this.stopped; }
   get isConnected(): boolean { return this.connected; }
-  get isFatal(): boolean { return false; }
 
-  onTask(cb: TaskCallback): void { this.taskCallbacks.push(cb); }
-  onClaimAck(cb: ClaimAckCallback): void { this.claimAckCallbacks.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); }
 
-  // ── Heartbeat (HTTP POST) ───────────────────────────────────────
+  override disconnect(): void {
+    super.disconnect();
+    this.markDisconnected();
+  }
 
-  private startHeartbeat(): void {
-    this.stopHeartbeat();
-    this.heartbeatTimer = setInterval(() => {
-      if (this.stopped) return;
-      void this.register();
-    }, HEARTBEAT_INTERVAL_MS);
+  protected override onPollSuccess(agentId: string | undefined): void {
+    if (!this.connected) {
+      this.connected = true;
+      this.options.log?.info?.("[clawroom] polling connected");
+      if (agentId) {
+        for (const cb of this.welcomeCallbacks) cb(agentId);
+      }
+    }
   }
 
-  private stopHeartbeat(): void {
-    if (this.heartbeatTimer) { clearInterval(this.heartbeatTimer); this.heartbeatTimer = null; }
+  protected override onPollError(_err: unknown): void {
+    this.markDisconnected();
   }
 
-  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);
+  protected override onHttpError(status: number, text: string): void {
+    if (status === 401) {
+      this.stopped = true;
+      this.markDisconnected();
+      for (const cb of this.fatalCallbacks) cb(`Unauthorized: ${text}`, 401);
     }
   }
 
@@ -104,104 +58,6 @@ export class ClawroomClient {
     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}`, 401);
-      }
-      throw new Error(`HTTP ${res.status}: ${text}`);
-    }
-    return res.json();
-  }
 }
+
+export type { ClawroomClientOptions };

package/src/task-executor.ts

@@ -1,4 +1,4 @@
-import type { ServerClaimAck, ServerTask, AgentResultFile } from "@clawroom/sdk";
+import type { ServerTask, AgentResultFile } from "@clawroom/sdk";
 import type { PluginRuntime } from "openclaw/plugin-sdk/core";
 import type { ClawroomClient } from "./client.js";
 import fs from "node:fs";
@@ -11,12 +11,10 @@ const SUBAGENT_TIMEOUT_MS = 5 * 60 * 1000;
 const MAX_FILE_SIZE = 10 * 1024 * 1024;
 
 /**
- * Wire up the task execution pipeline:
- *   1. On server.task -> store as available
- *   2. On claim_ack(ok) -> invoke subagent -> send result/fail
+ * Wire up the task execution pipeline.
  *
- * Tasks arrive through the polling client, either because the agent auto-claimed
- * them or because the owner manually claimed them from the dashboard.
+ * Tasks are assigned by humans and delivered via /poll.
+ * On receiving an assigned task, execute it immediately via subagent.
  */
 export function setupTaskExecutor(opts: {
   client: ClawroomClient;
@@ -28,43 +26,15 @@ export function setupTaskExecutor(opts: {
   };
 }): void {
   const { client, runtime, log } = opts;
-
-  // 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) => {
-    log?.info?.(`[clawroom:executor] received task ${task.taskId}: ${task.title}`);
-    knownTasks.set(task.taskId, task);
-  });
-
-  // Claim ack — either from plugin-initiated claim or Dashboard-initiated claim
-  client.onClaimAck((ack: ServerClaimAck) => {
-    if (!ack.ok) {
-      log?.warn?.(
-        `[clawroom:executor] claim rejected for ${ack.taskId}: ${ack.reason ?? "unknown"}`,
-      );
-      knownTasks.delete(ack.taskId);
-      return;
-    }
-
-    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}`,
-      );
+    if (activeTasks.has(task.taskId)) {
+      log?.info?.(`[clawroom:executor] task ${task.taskId} already running, skipping`);
       return;
     }
 
-    log?.info?.(`[clawroom:executor] executing task ${task.taskId}`);
+    log?.info?.(`[clawroom:executor] executing assigned task ${task.taskId}: ${task.title}`);
     activeTasks.add(task.taskId);
     void executeTask({ client, runtime, task, log }).finally(() => {
       activeTasks.delete(task.taskId);