clawmatrix 0.3.1 → 0.4.1

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/tools/cluster-peers.ts

@@ -41,6 +41,7 @@ export function createClusterPeersTool(): AnyAgentTool {
             const sentinelOnline = sentinelStatus === "direct" || sentinelStatus === "relay";
             const effectiveStatus = status === "unreachable" && sentinelOnline ? "sentinel-only" : status;
 
+            const channelCount = runtime.peerManager.router.getChannelCount(entry.nodeId);
             return {
               nodeId: entry.nodeId,
               agents: entry.agents.map((a) => ({
@@ -53,6 +54,7 @@ export function createClusterPeersTool(): AnyAgentTool {
               tools: entry.toolProxy?.enabled ? (entry.toolProxy.allow ?? []) : [],
               status: effectiveStatus,
               latencyMs: entry.latencyMs,
+              ...(channelCount > 1 ? { channels: channelCount } : {}),
               ...(hasSentinel ? {
                 sentinel: sentinelOnline ? "online" : "offline",
               } : {}),

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 {