clawmatrix 0.1.23 → 0.2.1

package/src/router.ts

@@ -1,4 +1,4 @@
-import type { ClusterFrame, AnyClusterFrame, PeerInfo, AgentInfo, ModelInfo, DeviceInfo, ToolProxyInfo } from "./types.ts";
+import type { ClusterFrame, AnyClusterFrame, PeerInfo, AgentInfo, ModelInfo, DeviceInfo, ToolProxyInfo, AcpAgentInfo } from "./types.ts";
 import type { Connection } from "./connection.ts";
 
 const DEFAULT_TTL = 3;
@@ -17,6 +17,7 @@ export interface RouteEntry {
   directPeers: string[]; // nodeIds this node has direct connections to
   deviceInfo?: DeviceInfo;
   toolProxy?: ToolProxyInfo;
+  acpAgents?: AcpAgentInfo[];
 }
 
 export class Router {
@@ -26,6 +27,7 @@ export class Router {
   private localTags: string[];
   private localDeviceInfo?: DeviceInfo;
   private localToolProxy?: ToolProxyInfo;
+  private localAcpAgents?: AcpAgentInfo[];
   private routes = new Map<string, RouteEntry>();
   private connections = new Map<string, Connection>(); // nodeId → direct connection
   /** Double-map dedup: current window + previous window. Rotated periodically. */
@@ -37,7 +39,7 @@ export class Router {
 
   constructor(
     nodeId: string,
-    localCapabilities?: { agents: AgentInfo[]; models: ModelInfo[]; tags: string[]; deviceInfo?: DeviceInfo; toolProxy?: ToolProxyInfo },
+    localCapabilities?: { agents: AgentInfo[]; models: ModelInfo[]; tags: string[]; deviceInfo?: DeviceInfo; toolProxy?: ToolProxyInfo; acpAgents?: AcpAgentInfo[] },
   ) {
     this.nodeId = nodeId;
     this.localAgents = localCapabilities?.agents ?? [];
@@ -45,6 +47,7 @@ export class Router {
     this.localTags = localCapabilities?.tags ?? [];
     this.localDeviceInfo = localCapabilities?.deviceInfo;
     this.localToolProxy = localCapabilities?.toolProxy;
+    this.localAcpAgents = localCapabilities?.acpAgents;
 
     this.rotateTimer = setInterval(() => this.rotateSeenFrames(), ROTATE_INTERVAL);
   }
@@ -64,7 +67,7 @@ export class Router {
   addDirectPeer(
     nodeId: string,
     connection: Connection,
-    capabilities: { agents: AgentInfo[]; models: ModelInfo[]; tags: string[]; deviceInfo?: DeviceInfo; toolProxy?: ToolProxyInfo },
+    capabilities: { agents: AgentInfo[]; models: ModelInfo[]; tags: string[]; deviceInfo?: DeviceInfo; toolProxy?: ToolProxyInfo; acpAgents?: AcpAgentInfo[] },
   ) {
     this.connections.set(nodeId, connection);
     this.routes.set(nodeId, {
@@ -79,6 +82,7 @@ export class Router {
       directPeers: [],
       deviceInfo: capabilities.deviceInfo,
       toolProxy: capabilities.toolProxy,
+      acpAgents: capabilities.acpAgents,
     });
   }
 
@@ -89,6 +93,10 @@ export class Router {
     const existing = this.routes.get(peer.nodeId);
     if (existing?.connection) return;
 
+    // Estimate relay latency: local→relay RTT + relay→target RTT (from peer_sync)
+    const relayRoute = this.routes.get(viaNodeId);
+    const estimatedLatency = (relayRoute?.latencyMs ?? 0) + (peer.latencyMs ?? 0);
+
     this.routes.set(peer.nodeId, {
       nodeId: peer.nodeId,
       agents: peer.agents,
@@ -97,10 +105,11 @@ export class Router {
       connection: null,
       reachableVia: viaNodeId,
       lastSeen: Date.now(),
-      latencyMs: 0,
+      latencyMs: estimatedLatency,
       directPeers: peer.directPeers ?? [],
       deviceInfo: peer.deviceInfo,
       toolProxy: peer.toolProxy,
+      acpAgents: peer.acpAgents,
     });
   }
 
@@ -117,7 +126,7 @@ export class Router {
 
   updatePeerCapabilities(
     nodeId: string,
-    capabilities: { agents: AgentInfo[]; models: ModelInfo[]; tags: string[]; directPeers?: string[]; deviceInfo?: DeviceInfo; toolProxy?: ToolProxyInfo },
+    capabilities: { agents: AgentInfo[]; models: ModelInfo[]; tags: string[]; directPeers?: string[]; deviceInfo?: DeviceInfo; toolProxy?: ToolProxyInfo; acpAgents?: AcpAgentInfo[] },
   ) {
     const entry = this.routes.get(nodeId);
     if (entry) {
@@ -131,6 +140,7 @@ export class Router {
         entry.deviceInfo = capabilities.deviceInfo;
       }
       entry.toolProxy = capabilities.toolProxy;
+      entry.acpAgents = capabilities.acpAgents;
       entry.lastSeen = Date.now();
     }
   }
@@ -189,15 +199,21 @@ export class Router {
   resolveNode(target: string): RouteEntry | undefined {
     if (target.startsWith("tags:")) {
       const tag = target.slice(5);
-      let best: RouteEntry | undefined;
+      const candidates: RouteEntry[] = [];
       for (const entry of this.routes.values()) {
         if (entry.tags.includes(tag)) {
-          if (!best || (entry.connection && !best.connection) || entry.latencyMs < best.latencyMs) {
-            best = entry;
-          }
+          candidates.push(entry);
         }
       }
-      return best;
+      if (candidates.length === 0) return undefined;
+      // Sort: direct connections first, then by latency
+      candidates.sort((a, b) => {
+        const aDirect = a.connection ? 0 : 1;
+        const bDirect = b.connection ? 0 : 1;
+        if (aDirect !== bDirect) return aDirect - bDirect;
+        return a.latencyMs - b.latencyMs;
+      });
+      return candidates[0];
     }
     return this.routes.get(target);
   }
@@ -330,8 +346,12 @@ export class Router {
       directPeers: myDirectPeers,
       deviceInfo: this.localDeviceInfo,
       toolProxy: this.localToolProxy,
+      acpAgents: this.localAcpAgents,
     });
     for (const entry of this.routes.values()) {
+      // Same-nodeId 本地客户端（Mac/iOS）不出现在 peer_sync 中，
+      // 客户端通过 auth_ok 获取网关 capabilities，无需在此重复。
+      if (entry.nodeId === this.nodeId) continue;
       peers.push({
         nodeId: entry.nodeId,
         agents: entry.agents,
@@ -341,6 +361,8 @@ export class Router {
         directPeers: entry.directPeers.length > 0 ? entry.directPeers : undefined,
         deviceInfo: entry.deviceInfo,
         toolProxy: entry.toolProxy,
+        acpAgents: entry.acpAgents,
+        latencyMs: entry.latencyMs > 0 ? entry.latencyMs : undefined,
       });
     }
     return peers;

package/src/sentinel-manager.ts

@@ -0,0 +1,142 @@
+/**
+ * SentinelManager — spawns and manages the sentinel subprocess from the
+ * main ClawMatrix process.
+ *
+ * The sentinel is a detached child that maintains WS connections independently,
+ * surviving OpenClaw crashes so remote nodes can still diagnose the machine.
+ */
+
+import { fork, type ChildProcess } from "node:child_process";
+import { join, dirname } from "node:path";
+import { existsSync, readFileSync, mkdirSync, openSync } from "node:fs";
+import { homedir, tmpdir } from "node:os";
+import type { ClawMatrixConfig } from "./config.ts";
+
+export class SentinelManager {
+  private config: ClawMatrixConfig;
+  private child: ChildProcess | null = null;
+  private pidFile: string;
+
+  constructor(config: ClawMatrixConfig) {
+    this.config = config;
+    // Use ~/.openclaw/ for PID file (process.cwd() may be read-only, e.g. "/")
+    const pidDir = join(homedir() || tmpdir(), ".openclaw");
+    try { mkdirSync(pidDir, { recursive: true }); } catch { /* exists */ }
+    this.pidFile = join(pidDir, `.clawmatrix-sentinel-${config.nodeId}.pid`);
+  }
+
+  start() {
+    // The sentinel script path — resolve relative to this file
+    const sentinelPath = join(dirname(new URL(import.meta.url).pathname), "sentinel.ts");
+
+    // Sentinel stderr goes to a log file instead of a pipe to the parent.
+    // A pipe would break when the parent exits, crashing the sentinel.
+    const logFile = join(dirname(this.pidFile), `sentinel-${this.config.nodeId}.log`);
+    const logFd = openSync(logFile, "a");
+
+    // Fork with detached + IPC channel
+    this.child = fork(sentinelPath, [], {
+      detached: true,
+      stdio: ["ignore", "ignore", logFd, "ipc"],
+      // Use the same Node.js execPath; tsx/ts-node loader from parent is inherited
+      execArgv: this.resolveExecArgv(),
+    });
+
+    // Send config to sentinel via IPC (includes gateway PID for health checks)
+    // If sentinel has no explicit listenPort but the gateway is a listener,
+    // inherit the gateway's port for automatic takeover when gateway dies.
+    const sentinelListenPort = this.config.sentinel?.listenPort
+      ?? (this.config.listen ? this.config.listenPort : 0);
+    this.child.send({
+      type: "init",
+      config: {
+        nodeId: this.config.nodeId,
+        secret: this.config.secret,
+        peers: this.config.peers,
+        agents: this.config.agents,
+        models: this.config.models,
+        tags: this.config.tags,
+        e2ee: this.config.e2ee,
+        compression: this.config.compression,
+        pidFile: this.pidFile,
+        gatewayPid: process.pid,
+        listenPort: sentinelListenPort,
+        listenHost: this.config.sentinel?.listenHost ?? this.config.listenHost,
+        peerApproval: this.config.peerApproval ? {
+          enabled: this.config.peerApproval.enabled,
+          allowList: this.config.peerApproval.allowList,
+          persistPath: this.config.peerApproval.persistPath,
+        } : undefined,
+      },
+    });
+
+    // Unref so the parent doesn't wait for the sentinel to exit
+    this.child.unref();
+    // Disconnect IPC so the parent can exit cleanly.
+    // The sentinel switches to PID-based health checks on disconnect.
+    setTimeout(() => {
+      try {
+        this.child?.disconnect();
+      } catch {
+        // Already disconnected
+      }
+    }, 1000);
+  }
+
+  stop() {
+    // IPC is disconnected shortly after start, so use PID file for shutdown
+    if (existsSync(this.pidFile)) {
+      try {
+        const pid = parseInt(readFileSync(this.pidFile, "utf-8").trim(), 10);
+        if (pid) {
+          process.kill(pid, "SIGTERM");
+          // Wait briefly for the process to exit so the next start()
+          // doesn't race with a still-dying sentinel
+          const deadline = Date.now() + 3_000;
+          while (Date.now() < deadline) {
+            try {
+              process.kill(pid, 0);
+              // Still alive — brief spin
+              const waitUntil = Date.now() + 50;
+              while (Date.now() < waitUntil) { /* spin */ }
+            } catch {
+              break; // exited
+            }
+          }
+        }
+      } catch {
+        // Already gone
+      }
+    }
+
+    this.child = null;
+  }
+
+  private resolveExecArgv(): string[] {
+    // Inherit TypeScript loaders from the parent process so sentinel.ts can be executed.
+    // Common patterns: --loader tsx, --import tsx/esm, --require ts-node/register, etc.
+    // We filter in pairs: flag args like "--loader tsx" come as two separate entries,
+    // so we keep both the flag and its value when matched.
+    const result: string[] = [];
+    const argv = process.execArgv;
+    for (let i = 0; i < argv.length; i++) {
+      const arg = argv[i]!;
+      const isLoaderFlag =
+        arg === "--loader" || arg.startsWith("--loader=") ||
+        arg === "--import" || arg.startsWith("--import=") ||
+        arg === "--require" || arg.startsWith("--require=");
+      const isTsArg = arg.includes("tsx") || arg.includes("ts-node");
+
+      if (isLoaderFlag) {
+        result.push(arg);
+        // If flag doesn't have = value, next arg is the value
+        if (!arg.includes("=") && i + 1 < argv.length) {
+          result.push(argv[++i]!);
+        }
+      } else if (isTsArg) {
+        result.push(arg);
+      }
+    }
+    return result;
+  }
+}