clawmatrix 0.2.8 → 0.2.11

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clawmatrix",
-  "version": "0.2.8",
+  "version": "0.2.11",
   "description": "Decentralized mesh cluster plugin for OpenClaw — inter-gateway communication, model proxy, task handoff, and tool proxy.",
   "type": "module",
   "license": "MIT",

package/src/acp-proxy.ts

@@ -153,6 +153,8 @@ export class AcpProxy {
   private warmPool = new Map<string, AcpSession[]>();
   // Track pending prewarm timers so they can be cancelled on dispose
   private prewarmTimers = new Set<ReturnType<typeof setTimeout>>();
+  // Track pending retry timers for sendResponse so they can be cancelled on destroy
+  private retryTimers = new Set<ReturnType<typeof setTimeout>>();
   private disposed = false;
   // Agent daemon pool: long-lived process per agent type, reused across sessions
   private daemons = new Map<string, AgentDaemon>();
@@ -584,7 +586,7 @@ export class AcpProxy {
             let newSession: AcpSession;
             if (resumeAcpSessionId) {
               debug("acp", `Session "${sessionId}" not found, resuming via acpSessionId "${resumeAcpSessionId.slice(0, 8)}..."`);
-              const effectiveCwd = cwd ?? process.cwd();
+              const effectiveCwd = cwd || process.cwd();
               try {
                 newSession = await this.createSessionWithResume(agent, resumeAcpSessionId, effectiveCwd, from);
               } catch (resumeErr) {
@@ -611,7 +613,7 @@ export class AcpProxy {
               });
             }
             if (mode === "oneshot" && task) {
-              this.returnToReusePool(newSession, cwd ?? process.cwd());
+              this.returnToReusePool(newSession, cwd || process.cwd());
             }
           } else {
             // Re-create native session
@@ -671,7 +673,7 @@ export class AcpProxy {
             });
           }
           if (mode === "oneshot" && task) {
-            this.returnToReusePool(session, cwd ?? process.cwd());
+            this.returnToReusePool(session, cwd || process.cwd());
           }
         } else {
           // Create new native OpenClaw session
@@ -778,7 +780,8 @@ export class AcpProxy {
   /** Handle resume session request (receiver side): resume an ACP session and track it. */
   async handleResumeRequest(frame: AcpResumeRequest): Promise<void> {
     const { id, from, payload } = frame;
-    const { agent, acpSessionId, cwd } = payload;
+    const { agent, acpSessionId } = payload;
+    const cwd = payload.cwd || process.cwd();
 
     try {
       // Enforce concurrent session limit
@@ -1089,6 +1092,30 @@ export class AcpProxy {
       }
     } catch { /* no claude projects directory */ }
 
+    // 3. Search Codex sessions (~/.codex/sessions/YYYY/MM/DD/rollout-*-{sessionId}.jsonl)
+    // Reverse sort so we search recent dates first (most likely to match)
+    const codexSessionsDir = join(homedir(), ".codex", "sessions");
+    try {
+      const years = (await readdir(codexSessionsDir)).sort().reverse();
+      for (const year of years) {
+        const monthsDir = join(codexSessionsDir, year);
+        let months: string[];
+        try { months = (await readdir(monthsDir)).sort().reverse(); } catch { continue; }
+        for (const month of months) {
+          const daysDir = join(monthsDir, month);
+          let days: string[];
+          try { days = (await readdir(daysDir)).sort().reverse(); } catch { continue; }
+          for (const day of days) {
+            const dayDir = join(daysDir, day);
+            let files: string[];
+            try { files = await readdir(dayDir); } catch { continue; }
+            const match = files.find((f) => f.endsWith(`-${sessionId}.jsonl`));
+            if (match) return join(dayDir, match);
+          }
+        }
+      }
+    } catch { /* no codex sessions directory */ }
+
     return null;
   }
 
@@ -1221,6 +1248,7 @@ export class AcpProxy {
       },
       availableModes,
       currentModeId: response.modes?.currentModeId,
+
     };
 
     return session;
@@ -1313,7 +1341,7 @@ export class AcpProxy {
   // ── Internal: ACP session management (receiver) ────────────────
 
   private async createSession(agent: string, cwd: string | undefined, from: string): Promise<AcpSession> {
-    const effectiveCwd = cwd ?? process.cwd();
+    const effectiveCwd = cwd || process.cwd();
 
     // 1. Try daemon pool first (long-lived process, instant newSession)
     try {
@@ -1499,6 +1527,7 @@ export class AcpProxy {
       setStreamCallback: (cb) => { streamCallback = cb; },
       availableModes,
       currentModeId: response.modes?.currentModeId,
+
     };
 
     this.monitorProcess(session);
@@ -1752,9 +1781,21 @@ export class AcpProxy {
     cwd: string,
     from: string,
   ): Promise<AcpSession> {
-    return this.spawnAndConnect(agent, cwd, from, "createSessionWithResume", (conn) =>
-      conn.unstable_resumeSession({ sessionId: acpSessionId, cwd }),
-    );
+    return this.spawnAndConnect(agent, cwd, from, "createSessionWithResume", async (conn, effectiveCwd) => {
+      // Try session/load first (supported by Codex, Claude Code, and most ACP agents).
+      // It restores conversation history and replays it via notifications.
+      try {
+        const loadResp = await conn.loadSession({ sessionId: acpSessionId, cwd: effectiveCwd, mcpServers: [] });
+        debug("acp", `loadSession succeeded for ${agent} (acpSessionId=${acpSessionId.slice(0, 8)}...)`);
+        return { sessionId: acpSessionId, modes: loadResp.modes };
+      } catch (loadErr) {
+        debug("acp", `loadSession failed for ${agent}: ${errorMessage(loadErr)}, trying session/resume`);
+      }
+
+      // Fallback to session/resume (unstable, supported by Claude Code).
+      // Resumes without replaying history — faster but less widely supported.
+      return conn.unstable_resumeSession({ sessionId: acpSessionId, cwd: effectiveCwd });
+    });
   }
 
   /** Read all session stores from disk (OpenClaw + Claude Code). */
@@ -1995,11 +2036,14 @@ export class AcpProxy {
       const retryDelays = [2_000, 5_000, 10_000];
       let attempt = 0;
       const retry = () => {
-        if (attempt >= retryDelays.length) {
-          console.error(`[clawmatrix:acp] Failed to deliver acp_res to ${to} after ${retryDelays.length} retries`);
+        if (this.disposed || attempt >= retryDelays.length) {
+          if (!this.disposed) {
+            console.error(`[clawmatrix:acp] Failed to deliver acp_res to ${to} after ${retryDelays.length} retries`);
+          }
           return;
         }
-        setTimeout(() => {
+        const timer = setTimeout(() => {
+          this.retryTimers.delete(timer);
           frame.timestamp = Date.now();
           if (this.peerManager.sendTo(to, frame)) {
             debug("acp", `acp_res to ${to} delivered on retry ${attempt + 1}`);
@@ -2008,6 +2052,7 @@ export class AcpProxy {
             retry();
           }
         }, retryDelays[attempt]);
+        this.retryTimers.add(timer);
       };
       retry();
     }
@@ -2048,6 +2093,10 @@ export class AcpProxy {
 
     this.disposed = true;
 
+    // Cancel pending retry timers
+    for (const timer of this.retryTimers) clearTimeout(timer);
+    this.retryTimers.clear();
+
     // Cancel pending prewarm timers
     for (const timer of this.prewarmTimers) clearTimeout(timer);
     this.prewarmTimers.clear();
@@ -2256,6 +2305,62 @@ async function fetchSessionListFromDisk(): Promise<AcpSessionInfo[]> {
     // history.jsonl missing or unreadable — skip
   }
 
+  // 3. Codex session history (~/.codex/history.jsonl + session_index.jsonl)
+  try {
+    const codexDir = join(homedir(), ".codex");
+    // Read session index for titles
+    const titleMap = new Map<string, string>();
+    try {
+      const indexContent = await readFileText(join(codexDir, "session_index.jsonl"));
+      for (const line of indexContent.split("\n")) {
+        if (!line.trim()) continue;
+        try {
+          const entry = JSON.parse(line) as { id?: string; thread_name?: string };
+          if (entry.id && entry.thread_name) titleMap.set(entry.id, entry.thread_name);
+        } catch { /* skip */ }
+      }
+    } catch { /* index missing */ }
+
+    const codexHistoryPath = join(codexDir, "history.jsonl");
+    const codexContent = await readFileTail(codexHistoryPath, 512 * 1024);
+    const codexSessions = new Map<string, { title: string; updatedAt: number }>();
+
+    for (const line of codexContent.split("\n")) {
+      if (!line.trim()) continue;
+      try {
+        const entry = JSON.parse(line) as { session_id?: string; ts?: number; text?: string };
+        if (!entry.session_id) continue;
+        const existing = codexSessions.get(entry.session_id);
+        if (!existing) {
+          const title = (entry.text ?? "").replace(/\s+/g, " ").trim().slice(0, 120);
+          codexSessions.set(entry.session_id, {
+            title,
+            updatedAt: entry.ts ? entry.ts * 1000 : 0, // ts is in seconds
+          });
+        } else if (entry.ts && entry.ts * 1000 > existing.updatedAt) {
+          existing.updatedAt = entry.ts * 1000;
+        }
+      } catch { /* skip */ }
+    }
+
+    const codexResults: AcpSessionInfo[] = [];
+    const existingIds2 = new Set(results.map((r) => r.sessionId));
+    for (const [sessionId, info] of codexSessions) {
+      if (existingIds2.has(sessionId)) continue;
+      codexResults.push({
+        sessionId,
+        cwd: "",
+        title: titleMap.get(sessionId) ?? info.title,
+        updatedAt: info.updatedAt ? new Date(info.updatedAt).toISOString() : undefined,
+        agent: "codex",
+      });
+    }
+    codexResults.sort((a, b) => (b.updatedAt ?? "").localeCompare(a.updatedAt ?? ""));
+    results.push(...codexResults);
+  } catch {
+    // Codex history missing or unreadable — skip
+  }
+
   return results;
 }
 
@@ -2444,7 +2549,12 @@ function normalizeTranscriptMessages(lines: string[], limit: number): ChatHistor
   for (const line of lines) {
     try {
       const parsed = JSON.parse(line);
-      const msg = parsed?.message;
+
+      // Support both OpenClaw/Claude format (parsed.message) and Codex format (parsed.payload with type=response_item)
+      let msg: Record<string, unknown> | undefined = parsed?.message;
+      if (!msg && parsed?.type === "response_item" && parsed?.payload?.role) {
+        msg = parsed.payload;
+      }
       if (!msg) continue;
 
       const role = typeof msg.role === "string" ? msg.role : "";

package/src/cluster-service.ts

@@ -14,8 +14,10 @@ import { ModelProxy } from "./model-proxy.ts";
 import { ToolProxy, type GatewayInfo } from "./tool-proxy.ts";
 import { AcpProxy, readAllSessionStoresFromDisk } from "./acp-proxy.ts";
 import { TerminalManager } from "./terminal.ts";
+import { FileTransferManager } from "./file-transfer.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 +30,9 @@ import type {
   HandoffInputRequired,
   HandoffInput,
   KnowledgeSyncFrame,
+  HealthSyncFrame,
+  AvailabilityRequest,
+  AvailabilityResponse,
   ModelRequest,
   ModelResponse,
   ModelStreamChunk,
@@ -61,6 +66,11 @@ import type {
   TerminalResize,
   TerminalCloseRequest,
   TerminalCloseResponse,
+  FileTransferInit,
+  FileTransferAck,
+  FileTransferChunk,
+  FileTransferChunkAck,
+  FileTransferComplete,
 } from "./types.ts";
 
 function resolveGatewayInfo(openclawConfig: OpenClawConfig): GatewayInfo {
@@ -84,7 +94,9 @@ export class ClusterRuntime {
   readonly toolProxy: ToolProxy;
   readonly acpProxy: AcpProxy | null;
   readonly terminalManager: TerminalManager;
+  readonly fileTransferManager: FileTransferManager | null;
   knowledgeSync: KnowledgeSync | null = null;
+  healthTracker: HealthTracker;
   webHandler: WebHandler | null = null;
   private sentinelManager: SentinelManager | null = null;
   private logger: PluginLogger;
@@ -104,6 +116,13 @@ 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.fileTransferManager = config.fileTransfer?.enabled
+      ? new FileTransferManager(config, this.peerManager)
+      : null;
+    this.healthTracker = new HealthTracker({
+      nodeId: config.nodeId,
+      peerManager: this.peerManager,
+    });
   }
 
   start() {
@@ -115,11 +134,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 +155,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 +190,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 +202,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,12 +243,14 @@ 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();
     this.acpProxy?.destroy();
     this.terminalManager.destroy();
     this.modelProxy.stop();
+    this.fileTransferManager?.destroy();
     this.toolProxy.destroy();
     await this.peerManager.stop();
     this.logger.info(`[clawmatrix] Node "${this.config.nodeId}" stopped`);
@@ -316,6 +348,23 @@ export class ClusterRuntime {
           this.logger.error(`[clawmatrix] Knowledge sync error: ${err}`);
         });
         break;
+      case "health_sync":
+        this.healthTracker.handleSyncMessage(frame as HealthSyncFrame);
+        break;
+      case "availability_req": {
+        const af = frame as AvailabilityRequest;
+        const range = af.payload.range ?? "24h";
+        const data = this.healthTracker.getAvailability(range);
+        this.peerManager.sendTo(af.from, {
+          type: "availability_res",
+          id: af.id,
+          from: this.config.nodeId,
+          to: af.from,
+          timestamp: Date.now(),
+          payload: { success: true, data },
+        } as AvailabilityResponse);
+        break;
+      }
       case "acp_req":
         if (this.acpProxy) {
           this.acpProxy.handleRequest(frame as AcpTaskRequest).catch((err) => {
@@ -472,6 +521,23 @@ export class ClusterRuntime {
           frame as TerminalOpenRequest | TerminalOpenResponse | TerminalData | TerminalResize | TerminalCloseRequest | TerminalCloseResponse,
         );
         break;
+      case "file_transfer_init":
+        this.fileTransferManager?.handleInit(frame as FileTransferInit).catch((err) => {
+          this.logger.error(`[clawmatrix] File transfer init error: ${err}`);
+        });
+        break;
+      case "file_transfer_ack":
+        this.fileTransferManager?.handleAck(frame as FileTransferAck);
+        break;
+      case "file_transfer_chunk":
+        this.fileTransferManager?.handleChunk(frame as FileTransferChunk);
+        break;
+      case "file_transfer_chunk_ack":
+        this.fileTransferManager?.handleChunkAck(frame as FileTransferChunkAck);
+        break;
+      case "file_transfer_complete":
+        this.fileTransferManager?.handleComplete(frame as FileTransferComplete);
+        break;
     }
   }
 

package/src/config.ts

@@ -134,6 +134,14 @@ const TerminalConfigSchema = z.object({
   allowFrom: z.array(z.string()).default([]),
 }).optional();
 
+const FileTransferConfigSchema = z.object({
+  enabled: z.boolean().default(false),
+  chunkSize: z.number().default(262_144),       // 256KB
+  maxFileSize: z.number().default(104_857_600),  // 100MB
+  timeout: z.number().default(300_000),          // 5min per-chunk
+  allowedPaths: z.array(z.string()).default([]), // empty = no restriction
+}).optional();
+
 const AcpConfigSchema = z.object({
   enabled: z.boolean().default(false),
   /** ACP agents available on this node. Advertised to peers via capabilities. */
@@ -169,6 +177,7 @@ const RawClawMatrixConfigSchema = z.object({
   knowledge: KnowledgeConfigSchema,
   terminal: TerminalConfigSchema,
   acp: AcpConfigSchema,
+  fileTransfer: FileTransferConfigSchema,
   peerApproval: z.union([
     z.boolean(),           // true = required mode, false = disabled
     PeerApprovalConfigSchema,