@clawroom/openclaw 0.5.0 → 0.5.19

package/src/task-executor.ts

@@ -1,35 +1,67 @@
-import type { AgentResultFile } from "@clawroom/sdk";
+import type { AgentResultFile, ClawroomClient } from "@clawroom/sdk";
 import type { PluginRuntime } from "openclaw/plugin-sdk/core";
-import type { ClawroomPluginClient } from "./client.js";
 import fs from "node:fs";
 import path from "node:path";
+import { extractToolNames, reportPluginReflectionSoon } from "./reflections.js";
 
 const SUBAGENT_TIMEOUT_MS = 5 * 60 * 1000;
 const MAX_FILE_SIZE = 10 * 1024 * 1024;
 
+type TaskPayload = {
+  taskId: string;
+  title: string;
+  description?: string;
+  input?: string;
+  channelId?: string | null;
+};
+
 export function setupTaskExecutor(opts: {
-  client: ClawroomPluginClient;
+  client: ClawroomClient;
   runtime: PluginRuntime;
   log?: { info?: (m: string, ...a: unknown[]) => void; warn?: (m: string, ...a: unknown[]) => void; error?: (m: string, ...a: unknown[]) => void };
 }): void {
   const { client, runtime, log } = opts;
   const activeTasks = new Set<string>();
+  const pendingTasks: TaskPayload[] = [];
 
-  client.onAgentTask((agentId: string, task: any) => {
-    const key = `${agentId}:${task.taskId}`;
+  const handleTask = (typedTask: TaskPayload, agentId: string) => {
+    const key = `${agentId}:${typedTask.taskId}`;
     if (activeTasks.has(key)) return;
     activeTasks.add(key);
-    log?.info?.(`[clawroom:executor] [${agentId}] executing task ${task.taskId}: ${task.title}`);
-    void executeTask({ client, runtime, task, agentId, log }).finally(() => activeTasks.delete(key));
+    log?.info?.(`[clawroom:executor] [${agentId}] executing task ${typedTask.taskId}: ${typedTask.title}`);
+    void executeTask({ client, runtime, task: typedTask, agentId, log }).finally(() => activeTasks.delete(key));
+  };
+
+  const flushPending = (agentId: string) => {
+    if (pendingTasks.length === 0) return;
+    const queued = pendingTasks.splice(0, pendingTasks.length);
+    for (const task of queued) {
+      handleTask(task, agentId);
+    }
+  };
+
+  client.onConnected((agentId) => {
+    flushPending(agentId);
+  });
+
+  client.onTask((task) => {
+    const agentId = client.agentId;
+    const typedTask = task as TaskPayload;
+    if (!agentId) {
+      log?.warn?.("[clawroom:executor] received task before agent registration completed");
+      pendingTasks.push(typedTask);
+      return;
+    }
+    handleTask(typedTask, agentId);
   });
 }
 
 async function executeTask(opts: {
-  client: ClawroomPluginClient;
+  client: ClawroomClient;
   runtime: PluginRuntime;
-  task: any;
+  task: TaskPayload;
   agentId: string;
-  log?: { info?: (m: string, ...a: unknown[]) => void; error?: (m: string, ...a: unknown[]) => void };
+  log?: { info?: (m: string, ...a: unknown[]) => void; warn?: (m: string, ...a: unknown[]) => void; error?: (m: string, ...a: unknown[]) => void };
 }): Promise<void> {
   const { client, runtime, task, agentId, log } = opts;
   const sessionKey = `clawroom:task:${agentId}:${task.taskId}`;
@@ -37,31 +69,58 @@ async function executeTask(opts: {
   const parts: string[] = [`# Task: ${task.title}`];
   if (task.description) parts.push("", task.description);
   if (task.input) parts.push("", "## Input", "", task.input);
-  if (task.skillTags?.length) parts.push("", `Skills: ${task.skillTags.join(", ")}`);
   const agentMessage = parts.join("\n");
+  let shouldDeleteSession = false;
 
   try {
+    reportPluginReflectionSoon(client, {
+      scope: "task",
+      status: "started",
+      summary: `Started task ${task.taskId}: ${task.title}`,
+      taskId: task.taskId,
+      channelId: task.channelId ?? null,
+    }, log);
+
     const { runId } = await runtime.subagent.run({
       sessionKey,
       idempotencyKey: `clawroom:${agentId}:${task.taskId}`,
       message: agentMessage,
       extraSystemPrompt:
-        "You are executing a task from ClawRoom. Complete it and provide a SHORT summary (2-3 sentences). " +
+        "You are executing a tracked task from ClawRoom. Treat the task as the durable execution record. " +
+        "Stay within the task scope and done definition; do not widen the mission on your own. " +
+        "If the task is blocked, explain the concrete blocker instead of hand-waving. " +
+        "Complete it and provide a SHORT summary (2-3 sentences). " +
         "Do NOT include local file paths or internal details. " +
         "If you create output files, list them at the end prefixed with 'OUTPUT_FILE: /path'.",
       lane: "clawroom",
     });
+    shouldDeleteSession = true;
 
     const waitResult = await runtime.subagent.waitForRun({ runId, timeoutMs: SUBAGENT_TIMEOUT_MS });
 
     if (waitResult.status === "error") {
       log?.error?.(`[clawroom:executor] [${agentId}] subagent error: ${waitResult.error}`);
-      await client.sendFail(agentId, task.taskId, waitResult.error ?? "Agent execution failed");
+      reportPluginReflectionSoon(client, {
+        scope: "task",
+        status: "error",
+        summary: `Task ${task.taskId} failed.`,
+        taskId: task.taskId,
+        channelId: task.channelId ?? null,
+        responseExcerpt: (waitResult.error ?? "Agent execution failed").slice(0, 400),
+      }, log);
+      await client.sendFail(task.taskId, waitResult.error ?? "Agent execution failed");
       return;
     }
     if (waitResult.status === "timeout") {
       log?.error?.(`[clawroom:executor] [${agentId}] subagent timeout`);
-      await client.sendFail(agentId, task.taskId, "Agent execution timed out");
+      reportPluginReflectionSoon(client, {
+        scope: "task",
+        status: "timeout",
+        summary: `Task ${task.taskId} timed out.`,
+        taskId: task.taskId,
+        channelId: task.channelId ?? null,
+      }, log);
+      await client.sendFail(task.taskId, "Agent execution timed out");
       return;
     }
 
@@ -72,12 +131,41 @@ async function executeTask(opts: {
     const output = rawOutput.split("\n").filter((l) => !l.match(/OUTPUT_FILE:\s*/)).join("\n").replace(/`?\/\S+\/[^\s`]+`?/g, "").replace(/\n{3,}/g, "\n\n").trim();
 
     log?.info?.(`[clawroom:executor] [${agentId}] task completed${files.length > 0 ? ` (${files.length} files)` : ""}`);
-    await client.sendComplete(agentId, task.taskId, output, files.length > 0 ? files : undefined);
-    await runtime.subagent.deleteSession({ sessionKey, deleteTranscript: true });
+    await client.sendComplete(task.taskId, output, files.length > 0 ? files : undefined);
+    reportPluginReflectionSoon(client, {
+      scope: "task",
+      status: "completed",
+      summary: `Completed task ${task.taskId}: ${task.title}`,
+      taskId: task.taskId,
+      channelId: task.channelId ?? null,
+      toolsUsed: extractToolNames(messages),
+      responseExcerpt: output.slice(0, 400),
+      detail: {
+        attachmentCount: files.length,
+      },
+    }, log);
+
+    // Report completion in channel
+    if (task.channelId && output) {
+      const summary = output.length > 200 ? output.slice(0, 200) + "..." : output;
+      await client.sendChatReply(task.channelId, `✅ 完成任务「${task.title}」：${summary}`).catch(() => {});
+    }
   } catch (err) {
     const reason = err instanceof Error ? err.message : String(err);
     log?.error?.(`[clawroom:executor] [${agentId}] error: ${reason}`);
-    await client.sendFail(agentId, task.taskId, reason);
+    reportPluginReflectionSoon(client, {
+      scope: "task",
+      status: "error",
+      summary: `Unexpected failure while executing task ${task.taskId}.`,
+      taskId: task.taskId,
+      channelId: task.channelId ?? null,
+      responseExcerpt: reason.slice(0, 400),
+    }, log);
+    await client.sendFail(task.taskId, reason);
+  } finally {
+    if (shouldDeleteSession) {
+      await runtime.subagent.deleteSession({ sessionKey, deleteTranscript: true }).catch(() => {});
+    }
   }
 }
 
@@ -107,7 +195,8 @@ function extractWrittenFiles(messages: unknown[]): string[] {
       const raw = b.input ?? b.arguments;
       const input = typeof raw === "string" ? (() => { try { return JSON.parse(raw); } catch { return null; } })() : raw;
       if (input && typeof input === "object") {
-        const fp = (input as any).file_path ?? (input as any).path;
+        const typedInput = input as { file_path?: unknown; path?: unknown };
+        const fp = typedInput.file_path ?? typedInput.path;
         if (typeof fp === "string" && fp) files.add(fp);
       }
     }
@@ -127,7 +216,10 @@ const MIME_MAP: Record<string, string> = {
   ".gif": "image/gif", ".svg": "image/svg+xml", ".zip": "application/zip",
 };
 
-function readAllFiles(paths: string[], log?: { warn?: (m: string, ...a: unknown[]) => void; info?: (m: string, ...a: unknown[]) => void }): AgentResultFile[] {
+function readAllFiles(
+  paths: string[],
+  log?: { warn?: (m: string, ...a: unknown[]) => void },
+): AgentResultFile[] {
   const results: AgentResultFile[] = [];
   for (const fp of paths) {
     try {
@@ -136,7 +228,9 @@ function readAllFiles(paths: string[], log?: { warn?: (m: string, ...a: unknown[
       if (stat.size > MAX_FILE_SIZE) continue;
       const data = fs.readFileSync(fp);
       results.push({ filename: path.basename(fp), mimeType: MIME_MAP[path.extname(fp).toLowerCase()] ?? "application/octet-stream", data: data.toString("base64") });
-    } catch {}
+    } catch (error) {
+      log?.warn?.(`[clawroom:executor] failed to read output file ${fp}:`, error);
+    }
   }
   return results;
 }

package/src/client.ts

@@ -1,56 +0,0 @@
-import { ClawroomMachineClient } from "@clawroom/sdk";
-import type { ClawroomMachineClientOptions } from "@clawroom/sdk";
-
-type DisconnectCallback = () => void;
-type WelcomeCallback = (machineId: string) => void;
-type FatalCallback = (reason: string) => void;
-
-/**
- * Plugin-specific ClawRoom machine client.
- * Wraps ClawroomMachineClient with OpenClaw lifecycle hooks.
- */
-export class ClawroomPluginClient {
-  private inner: ClawroomMachineClient;
-  private disconnectCallbacks: DisconnectCallback[] = [];
-  private welcomeCallbacks: WelcomeCallback[] = [];
-  private fatalCallbacks: FatalCallback[] = [];
-
-  constructor(options: ClawroomMachineClientOptions) {
-    this.inner = new ClawroomMachineClient(options);
-  }
-
-  get isAlive(): boolean { return !this.inner.stopped; }
-  get isConnected(): boolean { return this.inner.connected; }
-
-  onDisconnect(cb: DisconnectCallback): void { this.disconnectCallbacks.push(cb); }
-  onWelcome(cb: WelcomeCallback): void { this.welcomeCallbacks.push(cb); }
-  onFatal(cb: FatalCallback): void { this.fatalCallbacks.push(cb); }
-
-  onAgentTask(handler: (agentId: string, task: any) => void) { this.inner.onAgentTask(handler); }
-  onAgentChat(handler: (agentId: string, messages: any[]) => void) { this.inner.onAgentChat(handler); }
-
-  async sendComplete(agentId: string, taskId: string, output: string, attachments?: Array<{ filename: string; mimeType: string; data: string }>) {
-    await this.inner.sendAgentComplete(agentId, taskId, output);
-  }
-
-  async sendFail(agentId: string, taskId: string, reason: string) {
-    await this.inner.sendAgentFail(agentId, taskId, reason);
-  }
-
-  async sendChatReply(agentId: string, channelId: string, content: string) {
-    await this.inner.sendAgentChatReply(agentId, channelId, content);
-  }
-
-  async sendTyping(agentId: string, channelId: string) {
-    await this.inner.sendAgentTyping(agentId, channelId);
-  }
-
-  connect(): void {
-    this.inner.connect();
-  }
-
-  disconnect(): void {
-    this.inner.disconnect();
-    for (const cb of this.disconnectCallbacks) cb();
-  }
-}