clawmatrix 0.3.1 → 0.4.0

package/src/tool-proxy.ts

@@ -10,6 +10,9 @@ import type {
 } from "./types.ts";
 import type { PluginLogger } from "openclaw/plugin-sdk";
 import { isLocalTool, executeLocally } from "./local-tools.ts";
+import { writeFileSync, mkdirSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
 
 const DEFAULT_TOOL_TIMEOUT = 30_000;
 
@@ -136,13 +139,41 @@ export class ToolProxy {
 
     if (frame.payload.success && frame.payload.result) {
       this.logger.info(`[clawmatrix] Tool response: id=${frame.id} from="${frame.from}" success`);
-      pending.resolve(frame.payload.result);
+      const result = this.extractInlineImage(frame.payload.result);
+      pending.resolve(result);
     } else {
       this.logger.warn(`[clawmatrix] Tool response: id=${frame.id} from="${frame.from}" failed: ${frame.payload.error}`);
       pending.reject(new Error(frame.payload.error ?? "Remote tool execution failed"));
     }
   }
 
+  /**
+   * If the tool result contains inline base64 image data (mime: "image/*" + data),
+   * save it to a local temp file and replace `data` with `localPath`.
+   * This avoids flooding the LLM context with base64 text (saves ~tens of thousands of tokens).
+   */
+  private extractInlineImage(result: Record<string, unknown>): Record<string, unknown> {
+    const mime = result.mime;
+    const data = result.data;
+    if (typeof mime !== "string" || !mime.startsWith("image/") || typeof data !== "string") {
+      return result;
+    }
+
+    try {
+      const ext = mime === "image/png" ? ".png" : mime === "image/webp" ? ".webp" : ".jpg";
+      const dir = join(tmpdir(), "clawmatrix-images");
+      mkdirSync(dir, { recursive: true });
+      const localPath = join(dir, `${Date.now()}-${Math.random().toString(36).slice(2, 8)}${ext}`);
+      writeFileSync(localPath, Buffer.from(data, "base64"));
+      this.logger.info(`[clawmatrix] Saved inline image (${(data.length * 0.75 / 1024).toFixed(0)}KB) to ${localPath}`);
+      const { data: _stripped, ...rest } = result;
+      return { ...rest, localPath };
+    } catch (err) {
+      this.logger.warn(`[clawmatrix] Failed to extract inline image: ${err}`);
+      return result;
+    }
+  }
+
   // ── Incoming request: execute via local Gateway ────────────────
   async handleRequest(frame: ToolProxyRequest): Promise<void> {
     const { id, from, payload } = frame;
@@ -288,7 +319,14 @@ export class ToolProxy {
 
     clearTimeout(pending.timer);
     this.pendingBatch.delete(frame.id);
-    pending.resolve(frame.payload.results);
+    // Extract inline images from batch results
+    const results = frame.payload.results.map((item) => {
+      if (item.success && item.result) {
+        return { ...item, result: this.extractInlineImage(item.result) };
+      }
+      return item;
+    });
+    pending.resolve(results);
   }
 
   // ── Incoming batch request: execute sequentially via local Gateway ──

package/src/tools/cluster-notify.ts

@@ -0,0 +1,132 @@
+import type { AnyAgentTool } from "openclaw/plugin-sdk";
+import { getClusterRuntime } from "../cluster-service.ts";
+import { randomUUID } from "node:crypto";
+
+export function createClusterNotifyTool(): AnyAgentTool {
+  return {
+    name: "cluster_notify",
+    label: "Cluster Notify",
+    description:
+      "Push a notification to mobile devices in the cluster (triggers Dynamic Island / Live Activity on iOS). " +
+      "Use this when you are about to start a long-running task so the user can track progress on their phone. " +
+      'Actions: "start" begins a new activity, "update" changes detail/progress, "end" dismisses it.',
+    parameters: {
+      type: "object",
+      properties: {
+        action: {
+          type: "string",
+          enum: ["start", "update", "end"],
+          description: 'Action to perform. Default: "start"',
+        },
+        taskId: {
+          type: "string",
+          description: "Task ID for update/end actions. Returned by start action. Omit for start to auto-generate.",
+        },
+        title: {
+          type: "string",
+          description: "Activity title (shown in Dynamic Island and lock screen)",
+        },
+        detail: {
+          type: "string",
+          description: "Activity detail text (e.g. current step description)",
+        },
+        progress: {
+          type: "number",
+          description: "Progress value 0.0 to 1.0 (optional, shows progress bar when provided)",
+        },
+        tool: {
+          type: "string",
+          description: "Current tool being executed (shown as a tag in the activity)",
+        },
+        success: {
+          type: "boolean",
+          description: 'For "end" action: true for completed, false for failed. Default: true',
+        },
+      },
+      required: [],
+    },
+    async execute(_toolCallId, params) {
+      const {
+        action = "start",
+        taskId: providedTaskId,
+        title,
+        detail,
+        progress,
+        tool,
+        success = true,
+      } = params as {
+        action?: "start" | "update" | "end";
+        taskId?: string;
+        title?: string;
+        detail?: string;
+        progress?: number;
+        tool?: string;
+        success?: boolean;
+      };
+
+      try {
+        const runtime = getClusterRuntime();
+        const peers = runtime.peerManager.router.getAllPeers();
+        const mobileTargets = peers.filter((p) =>
+          p.tags.some((t) => t === "mobile" || t === "ios" || t === "phone"),
+        );
+
+        if (mobileTargets.length === 0) {
+          return {
+            content: [{ type: "text" as const, text: "No mobile peers connected" }],
+            details: { error: true },
+          };
+        }
+
+        const taskId = providedTaskId || randomUUID();
+        const now = Date.now();
+
+        let status: string;
+        if (action === "start") status = "started";
+        else if (action === "end") status = success ? "completed" : "failed";
+        else status = "progress";
+
+        const frame = {
+          type: "task_activity" as const,
+          id: randomUUID(),
+          from: runtime.config.nodeId,
+          timestamp: now,
+          payload: {
+            taskId,
+            taskType: "notify" as const,
+            status,
+            agent: title || runtime.config.nodeId,
+            nodeId: runtime.config.nodeId,
+            title: title || runtime.config.nodeId,
+            detail: detail || (action === "end" ? (success ? "已完成" : "失败") : undefined),
+            startedAt: now,
+            elapsedMs: 0,
+            progress,
+            tool,
+          },
+        };
+
+        for (const target of mobileTargets) {
+          runtime.peerManager.sendTo(target.nodeId, { ...frame, to: target.nodeId });
+        }
+
+        const targetNames = mobileTargets.map((t) => t.nodeId).join(", ");
+        return {
+          content: [{
+            type: "text" as const,
+            text: `Notification ${action}ed → ${targetNames} (taskId: ${taskId})`,
+          }],
+          details: { taskId, action, targets: mobileTargets.length },
+        };
+      } catch (err) {
+        return {
+          content: [{
+            type: "text" as const,
+            text: `Notify error: ${err instanceof Error ? err.message : String(err)}`,
+          }],
+          details: { error: true },
+        };
+      }
+    },
+  };
+}

package/src/types.ts

@@ -620,7 +620,7 @@ export interface AcpSessionInfo {
   description?: string;     // first user message (for display in session list)
   updatedAt?: string;
   agent?: string;           // which ACP agent (claude, codex, etc.)
-  status?: "active" | "idle"; // active = in-memory session with daemon, idle = persisted on disk
+  status?: "busy" | "active" | "idle"; // busy = currently executing a prompt, active = daemon alive, idle = on disk only
 }
 
 export interface AcpListRequest extends ClusterFrame {