@clawroom/sdk 0.3.0 → 0.5.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@clawroom/sdk",
-  "version": "0.3.0",
+  "version": "0.5.0",
   "description": "ClawRoom SDK — polling client and protocol types for connecting any agent to ClawRoom",
   "type": "module",
   "license": "MIT",

package/src/client.ts

@@ -21,6 +21,8 @@ export type ClawroomClientOptions = {
   deviceId: string;
   /** Agent skills */
   skills: string[];
+  /** Agent kind (e.g. "openclaw", "claude-code", "codex", "custom"). Defaults to "openclaw" */
+  kind?: string;
   /** Optional logger */
   log?: {
     info?: (message: string, ...args: unknown[]) => void;
@@ -117,6 +119,7 @@ export class ClawroomClient {
       await this.httpRequest("POST", "/heartbeat", {
         deviceId: this.options.deviceId,
         skills: this.options.skills,
+        kind: this.options.kind ?? "openclaw",
       });
       this.onPollSuccess(undefined);
     } catch (err) {

package/src/index.ts

@@ -1,5 +1,7 @@
 export { ClawroomClient } from "./client.js";
 export type { ClawroomClientOptions } from "./client.js";
+export { ClawroomMachineClient } from "./machine-client.js";
+export type { ClawroomMachineClientOptions } from "./machine-client.js";
 
 export type {
   AgentMessage,

package/src/machine-client.ts

@@ -0,0 +1,127 @@
+/**
+ * ClawRoom Machine Client — machine-level auth with multi-agent support.
+ */
+
+import * as os from "node:os";
+
+export type ClawroomMachineClientOptions = {
+  endpoint?: string;
+  apiKey: string;
+  hostname?: string;
+  capabilities?: string[];
+  log?: {
+    info?: (message: string, ...args: unknown[]) => void;
+    warn?: (message: string, ...args: unknown[]) => void;
+    error?: (message: string, ...args: unknown[]) => void;
+  };
+};
+
+type AgentWork = {
+  agentId: string;
+  agentName: string;
+  task: { type: "server.task"; taskId: string; title: string; description: string; input: string; skillTags: string[] } | null;
+  chat: Array<{ messageId: string; channelId: string; content: string; isMention: boolean; context: unknown[] }> | null;
+};
+
+export class ClawroomMachineClient {
+  private options: ClawroomMachineClientOptions;
+  private heartbeatTimer: ReturnType<typeof setInterval> | null = null;
+  private pollTimer: ReturnType<typeof setInterval> | null = null;
+  private taskHandler: ((agentId: string, task: AgentWork["task"]) => void) | null = null;
+  private chatHandler: ((agentId: string, messages: NonNullable<AgentWork["chat"]>) => void) | null = null;
+  private _connected = false;
+  private _stopped = false;
+
+  constructor(options: ClawroomMachineClientOptions) {
+    this.options = options;
+  }
+
+  private get baseUrl(): string {
+    return this.options.endpoint ?? "http://localhost:3000/api/machines";
+  }
+
+  private async httpRequest(method: string, path: string, body?: unknown): Promise<unknown> {
+    const url = `${this.baseUrl}${path}`;
+    const res = await fetch(url, {
+      method,
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${this.options.apiKey}`,
+      },
+      body: body ? JSON.stringify(body) : undefined,
+    });
+    if (!res.ok) throw new Error(`HTTP ${res.status}: ${await res.text()}`);
+    return res.json();
+  }
+
+  onAgentTask(handler: (agentId: string, task: AgentWork["task"]) => void) {
+    this.taskHandler = handler;
+  }
+
+  onAgentChat(handler: (agentId: string, messages: NonNullable<AgentWork["chat"]>) => void) {
+    this.chatHandler = handler;
+  }
+
+  async sendAgentComplete(agentId: string, taskId: string, output: string) {
+    // Use agent-level API via machine auth proxy (or direct)
+    await this.httpRequest("POST", "/complete", { agentId, taskId, output });
+  }
+
+  async sendAgentFail(agentId: string, taskId: string, reason: string) {
+    await this.httpRequest("POST", "/fail", { agentId, taskId, reason });
+  }
+
+  async sendAgentChatReply(agentId: string, channelId: string, content: string) {
+    await this.httpRequest("POST", "/chat-reply", { agentId, channelId, content });
+  }
+
+  async sendAgentTyping(agentId: string, channelId: string) {
+    await this.httpRequest("POST", "/typing", { agentId, channelId });
+  }
+
+  get connected() { return this._connected; }
+  get stopped() { return this._stopped; }
+
+  connect() {
+    this._stopped = false;
+    const hostname = this.options.hostname ?? os.hostname();
+    const hbBody = { hostname, capabilities: this.options.capabilities };
+
+    // Heartbeat every 30s
+    this.heartbeatTimer = setInterval(async () => {
+      try {
+        await this.httpRequest("POST", "/heartbeat", hbBody);
+        if (!this._connected) { this._connected = true; this.options.log?.info?.("[machine] connected"); }
+      } catch (err) {
+        if (this._connected) { this._connected = false; this.options.log?.warn?.("[machine] disconnected"); }
+        this.options.log?.warn?.(`[machine] heartbeat error: ${err}`);
+      }
+    }, 30_000);
+
+    // Initial heartbeat
+    this.httpRequest("POST", "/heartbeat", hbBody)
+      .then(() => { this._connected = true; this.options.log?.info?.("[machine] connected"); })
+      .catch((err) => this.options.log?.warn?.(`[machine] initial heartbeat failed: ${err}`));
+
+    // Poll every 10s
+    this.pollTimer = setInterval(async () => {
+      if (!this._connected) return;
+      try {
+        const result = (await this.httpRequest("POST", "/poll", {})) as { machineId: string; agents: AgentWork[] };
+        for (const agent of result.agents) {
+          if (agent.task && this.taskHandler) this.taskHandler(agent.agentId, agent.task);
+          if (agent.chat && agent.chat.length > 0 && this.chatHandler) this.chatHandler(agent.agentId, agent.chat);
+        }
+      } catch (err) {
+        this.options.log?.warn?.(`[machine] poll error: ${err}`);
+      }
+    }, 10_000);
+  }
+
+  disconnect() {
+    this._stopped = true;
+    this._connected = false;
+    if (this.heartbeatTimer) clearInterval(this.heartbeatTimer);
+    if (this.pollTimer) clearInterval(this.pollTimer);
+  }
+}

package/src/protocol.ts

@@ -68,6 +68,7 @@ export interface ServerChatMessage {
   messageId: string;
   channelId: string;
   content: string;
+  isMention: boolean;
   context: Array<{
     id: string;
     senderType: string;