clawmatrix 0.2.7 → 0.2.9

package/src/cluster-service.ts

@@ -16,6 +16,7 @@ import { AcpProxy, readAllSessionStoresFromDisk } from "./acp-proxy.ts";
 import { TerminalManager } from "./terminal.ts";
 import { WebHandler } from "./web.ts";
 import { KnowledgeSync } from "./knowledge-sync.ts";
+import { HealthTracker } from "./health-tracker.ts";
 import { SentinelManager } from "./sentinel-manager.ts";
 import type {
   AnyClusterFrame,
@@ -28,6 +29,7 @@ import type {
   HandoffInputRequired,
   HandoffInput,
   KnowledgeSyncFrame,
+  HealthSyncFrame,
   ModelRequest,
   ModelResponse,
   ModelStreamChunk,
@@ -85,6 +87,7 @@ export class ClusterRuntime {
   readonly acpProxy: AcpProxy | null;
   readonly terminalManager: TerminalManager;
   knowledgeSync: KnowledgeSync | null = null;
+  healthTracker: HealthTracker;
   webHandler: WebHandler | null = null;
   private sentinelManager: SentinelManager | null = null;
   private logger: PluginLogger;
@@ -104,6 +107,10 @@ export class ClusterRuntime {
     const acpEnabled = config.acp?.enabled || (openclawConfig as Record<string, any>).acp?.enabled;
     this.acpProxy = acpEnabled ? new AcpProxy(config, this.peerManager, openclawConfig as Record<string, unknown>, gatewayInfo) : null;
     this.terminalManager = new TerminalManager(config, this.peerManager);
+    this.healthTracker = new HealthTracker({
+      nodeId: config.nodeId,
+      peerManager: this.peerManager,
+    });
   }
 
   start() {
@@ -115,11 +122,15 @@ export class ClusterRuntime {
     this.peerManager.on("peerConnected", (nodeId) => {
       this.logger.info(`[clawmatrix] Peer connected: ${nodeId}`);
       this.refreshDiscoveredModels();
+      this.healthTracker.recordPeerOnline(nodeId, "direct");
+      this.healthTracker.initPeerSync(nodeId);
     });
 
     this.peerManager.on("peerDisconnected", (nodeId) => {
       this.logger.info(`[clawmatrix] Peer disconnected: ${nodeId}`);
       this.refreshDiscoveredModels();
+      this.healthTracker.recordPeerOffline(nodeId);
+      this.healthTracker.removePeerSync(nodeId);
     });
 
     this.peerManager.on("peerCapabilitiesChanged", () => {
@@ -132,6 +143,7 @@ export class ClusterRuntime {
       this.peerManager.setHttpHandler((req, res) => this.webHandler!.handle(req, res));
       // Enable satellite tool routing through WebHandler
       this.toolProxy.setSatelliteHandler(this.webHandler);
+      this.webHandler.setHealthTracker(this.healthTracker);
       this.logger.info(`[clawmatrix] Web dashboard enabled on listen port`);
     }
 
@@ -166,8 +178,9 @@ export class ClusterRuntime {
     }
 
     // Auto-detect ACP agents if ACP is enabled but no agents are explicitly configured
-    if (this.acpProxy && this.config.acp?.enabled && (!this.config.acp.agents || this.config.acp.agents.length === 0)) {
-      AcpProxy.detectAvailableAgents(this.config.acp.commands).then((detected) => {
+    // Check both ClawMatrix and OpenClaw configs (consistent with acpProxy creation above)
+    if (this.acpProxy && (!this.config.acp?.agents || this.config.acp.agents.length === 0)) {
+      AcpProxy.detectAvailableAgents(this.config.acp?.commands).then((detected) => {
         if (detected.length > 0) {
           this.logger.info(`[clawmatrix] Auto-detected ACP agents: ${detected.map((a) => a.id).join(", ")}`);
           this.peerManager.updateAcpAgents(detected);
@@ -177,6 +190,11 @@ export class ClusterRuntime {
       });
     }
 
+    // Health tracker (always enabled, no config gate)
+    this.healthTracker.start().catch((err) => {
+      this.logger.error(`[clawmatrix] Health tracker failed to start: ${err}`);
+    });
+
     // Start subsystems
     this.peerManager.start();
     this.modelProxy.start();
@@ -213,6 +231,7 @@ export class ClusterRuntime {
     // NOTE: intentionally do NOT stop sentinel here.
     // Sentinel must survive gateway shutdown — that's its entire purpose.
     // It will be replaced by killOldSentinel() on next gateway start.
+    await this.healthTracker.stop();
     await this.knowledgeSync?.stop();
     this.webHandler?.destroy();
     this.handoffManager.destroy();
@@ -316,6 +335,9 @@ export class ClusterRuntime {
           this.logger.error(`[clawmatrix] Knowledge sync error: ${err}`);
         });
         break;
+      case "health_sync":
+        this.healthTracker.handleSyncMessage(frame as HealthSyncFrame);
+        break;
       case "acp_req":
         if (this.acpProxy) {
           this.acpProxy.handleRequest(frame as AcpTaskRequest).catch((err) => {

package/src/compat.ts

@@ -5,7 +5,7 @@
  */
 
 import { spawn as cpSpawn } from "node:child_process";
-import { readFile, writeFile } from "node:fs/promises";
+import { open, readFile, stat, writeFile } from "node:fs/promises";
 import { createRequire } from "node:module";
 
 export interface SpawnResult {
@@ -167,6 +167,41 @@ export async function readFileText(path: string): Promise<string> {
   return readFile(path, "utf-8");
 }
 
+/** Read at most `bytes` bytes from the beginning of a file as text. */
+export async function readFileHead(path: string, bytes: number): Promise<string> {
+  const fh = await open(path, "r");
+  try {
+    const buf = Buffer.alloc(bytes);
+    const { bytesRead } = await fh.read(buf, 0, bytes, 0);
+    return buf.toString("utf-8", 0, bytesRead);
+  } finally {
+    await fh.close();
+  }
+}
+
+/** Read at most `bytes` bytes from the end of a file as text. */
+export async function readFileTail(path: string, bytes: number): Promise<string> {
+  const info = await stat(path);
+  const size = info.size;
+  if (size === 0) return "";
+  const readBytes = Math.min(bytes, size);
+  const offset = size - readBytes;
+  const fh = await open(path, "r");
+  try {
+    const buf = Buffer.alloc(readBytes);
+    const { bytesRead } = await fh.read(buf, 0, readBytes, offset);
+    const text = buf.toString("utf-8", 0, bytesRead);
+    // Drop the first (possibly partial) line if we didn't read from start
+    if (offset > 0) {
+      const nl = text.indexOf("\n");
+      return nl >= 0 ? text.slice(nl + 1) : text;
+    }
+    return text;
+  } finally {
+    await fh.close();
+  }
+}
+
 /** Write text to a file (replaces Bun.write()). */
 export async function writeFileText(path: string, content: string): Promise<void> {
   await writeFile(path, content, "utf-8");

package/src/handoff.ts

@@ -91,6 +91,7 @@ export class HandoffManager {
     for (const [id, entry] of this.active) {
       if (entry.status === "input_required" && entry.inputRequiredAt && now - entry.inputRequiredAt > INPUT_REQUIRED_TTL) {
         this.active.delete(id);
+        this.sessionWatchers.delete(entry.sessionId);
         // Notify the requester that the handoff timed out
         this.peerManager.sendTo(entry.from, {
           type: "handoff_res",
@@ -110,6 +111,7 @@ export class HandoffManager {
       // (e.g. cancel arrived during input_required when no process was running)
       if (entry.status === "canceled") {
         this.active.delete(id);
+        this.sessionWatchers.delete(entry.sessionId);
       }
     }
     // Clean stale inputRequiredTargets (requester side)
@@ -355,6 +357,7 @@ export class HandoffManager {
 
     if (activeEntry.status === "canceled") {
       this.active.delete(id);
+      this.sessionWatchers.delete(activeEntry.sessionId);
       return;
     }
 
@@ -401,11 +404,13 @@ export class HandoffManager {
 
       if (activeEntry.status === "canceled") {
         this.active.delete(id);
+        this.sessionWatchers.delete(activeEntry.sessionId);
         return;
       }
 
       activeEntry.status = "completed";
       this.active.delete(id);
+      this.sessionWatchers.delete(activeEntry.sessionId);
 
       // Broadcast task completed
       this.taskActivity.broadcast(id, "handoff", "completed", agent, activeEntry.startedAt);
@@ -429,10 +434,12 @@ export class HandoffManager {
     } catch (err) {
       if (activeEntry.status === "canceled") {
         this.active.delete(id);
+        this.sessionWatchers.delete(activeEntry.sessionId);
         return;
       }
       activeEntry.status = "failed";
       this.active.delete(id);
+      this.sessionWatchers.delete(activeEntry.sessionId);
 
       // Broadcast task failed
       this.taskActivity.broadcast(
@@ -468,7 +475,7 @@ export class HandoffManager {
 
     const reader = body.getReader();
     const decoder = new TextDecoder();
-    let full = "";
+    const chunks: string[] = [];
     let buffer = "";
 
     try {
@@ -489,7 +496,7 @@ export class HandoffManager {
             const parsed = JSON.parse(data);
             const delta = parsed.choices?.[0]?.delta?.content;
             if (delta) {
-              full += delta;
+              chunks.push(delta);
               const streamFrame: HandoffStreamChunk = {
                 type: "handoff_stream",
                 id: handoffId,
@@ -531,7 +538,7 @@ export class HandoffManager {
     this.peerManager.sendTo(to, doneFrame);
     if (sessionId) this.sendToOtherWatchers(sessionId, to, doneFrame);
 
-    return full;
+    return chunks.join("");
   }
 
   /** Handle incoming input_required from remote (requester side). */