clawmatrix 0.5.1 → 0.6.1

package/src/automation.ts

@@ -27,7 +27,14 @@ export interface AutomationTrigger {
   type: "event" | "schedule";
   source?: string;
   eventType?: string;
+  /** Interval-based schedule: repeat every N milliseconds (min 10s). */
   intervalMs?: number;
+  /** Daily schedule: time of day in "HH:MM" (24h) format. */
+  dailyTime?: string;
+  /** IANA timezone for daily schedule (default: system timezone). */
+  timezone?: string;
+  /** Days of week to run (0=Sun, 1=Mon, ..., 6=Sat). Empty/undefined = every day. */
+  daysOfWeek?: number[];
 }
 
 export interface AutomationCondition {
@@ -318,6 +325,27 @@ export class AutomationManager {
 
   async saveRules(rules: AutomationRule[]): Promise<void> {
     const normalized = rules.map((rule) => ({ ...rule, action: normalizeAction(rule.action) }));
+    for (const rule of normalized) {
+      const action = rule.action;
+      if (action.type === "handoff" || action.type == null) {
+        const handoff = action as AutomationHandoffAction;
+        if (!handoff.agent || !handoff.agent.trim()) {
+          throw new Error(`Rule "${rule.name || rule.id}": handoff action requires a non-empty agent`);
+        }
+        if (!handoff.task || !handoff.task.trim()) {
+          throw new Error(`Rule "${rule.name || rule.id}": handoff action requires a non-empty task`);
+        }
+      }
+      if (action.type === "tool") {
+        const tool = action as AutomationToolAction;
+        if (!tool.node || !tool.node.trim()) {
+          throw new Error(`Rule "${rule.name || rule.id}": tool action requires a non-empty node`);
+        }
+        if (!tool.tool || !tool.tool.trim()) {
+          throw new Error(`Rule "${rule.name || rule.id}": tool action requires a non-empty tool name`);
+        }
+      }
+    }
     const content: AutomationsFile = { rules: normalized };
     await writeFile(this.filePath, JSON.stringify(content, null, 2), "utf-8");
     this.stopScheduleTimers();
@@ -523,7 +551,7 @@ export class AutomationManager {
           title,
           detail,
           progress,
-          status: success ? "completed" : "error",
+          status: success ? "completed" : "failed",
         },
       });
     } catch {
@@ -577,6 +605,13 @@ export class AutomationManager {
     for (const rule of this.rules) {
       if (!rule.enabled) continue;
       if (rule.trigger.type !== "schedule") continue;
+
+      if (rule.trigger.dailyTime) {
+        // Daily schedule: check every 30s if we should fire
+        this.scheduleDailyTimer(rule);
+        continue;
+      }
+
       if (!rule.trigger.intervalMs || rule.trigger.intervalMs < 10_000) continue;
 
       const timer = setInterval(() => {
@@ -589,6 +624,60 @@ export class AutomationManager {
     }
   }
 
+  private scheduleDailyTimer(rule: AutomationRule): void {
+    const CHECK_INTERVAL = 30_000; // Check every 30s
+    const fired = new Set<string>(); // Track fired dates to prevent double-fire
+
+    const timer = setInterval(() => {
+      const { dailyTime, timezone, daysOfWeek } = rule.trigger;
+      if (!dailyTime) return;
+
+      const now = new Date();
+      // Format current time in the target timezone
+      const formatter = new Intl.DateTimeFormat("en-US", {
+        timeZone: timezone || undefined,
+        hour: "2-digit",
+        minute: "2-digit",
+        hour12: false,
+        weekday: "short",
+        year: "numeric",
+        month: "2-digit",
+        day: "2-digit",
+      });
+      const parts = Object.fromEntries(
+        formatter.formatToParts(now).map((p) => [p.type, p.value]),
+      );
+
+      const currentTime = `${parts.hour}:${parts.minute}`;
+      const dateKey = `${parts.year}-${parts.month}-${parts.day}`;
+
+      // Check time match (within 1-minute window)
+      if (currentTime !== dailyTime) return;
+
+      // Check day-of-week filter
+      if (daysOfWeek && daysOfWeek.length > 0) {
+        const dayMap: Record<string, number> = { Sun: 0, Mon: 1, Tue: 2, Wed: 3, Thu: 4, Fri: 5, Sat: 6 };
+        const currentDay = dayMap[parts.weekday] ?? now.getDay();
+        if (!daysOfWeek.includes(currentDay)) return;
+      }
+
+      // Prevent double-fire within same date
+      if (fired.has(dateKey)) return;
+      fired.add(dateKey);
+      // Cleanup old entries
+      if (fired.size > 7) {
+        const entries = [...fired];
+        entries.slice(0, entries.length - 7).forEach((k) => fired.delete(k));
+      }
+
+      if (!this.isOnCooldown(rule)) {
+        void this.executeRule(rule);
+      }
+    }, CHECK_INTERVAL);
+
+    this.scheduleTimers.set(rule.id, timer);
+  }
+
   private stopScheduleTimers(): void {
     for (const timer of this.scheduleTimers.values()) {
       clearInterval(timer);

package/src/cluster-service.ts

@@ -237,6 +237,10 @@ export class ClusterRuntime {
         });
         this.knowledgeSync.start().then(() => {
           this.logger.info(`[clawmatrix] Knowledge sync started: ${workspacePath}`);
+          // Sync with any peers that connected before start() completed
+          for (const peerId of this.peerManager.router.getDirectPeerIds()) {
+            this.knowledgeSync?.initPeerSync(peerId);
+          }
         }).catch((err) => {
           this.logger.error(`[clawmatrix] Knowledge sync failed to start: ${err}`);
         });
@@ -643,15 +647,26 @@ export class ClusterRuntime {
       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);
+        try {
+          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);
+        } catch (err) {
+          this.peerManager.sendTo(af.from, {
+            type: "availability_res",
+            id: af.id,
+            from: this.config.nodeId,
+            to: af.from,
+            timestamp: Date.now(),
+            payload: { success: false, error: String((err as Error)?.message ?? err) },
+          } as AvailabilityResponse);
+        }
         break;
       }
       case "acp_req":

package/src/config.ts

@@ -133,23 +133,29 @@ 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 FileTransferConfigSchema = z.preprocess(
+  (v) => v ?? {},
+  z.object({
+    enabled: z.boolean().default(true),
+    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
+  }),
+).default({});
 
-const KanbanConfigSchema = z.object({
-  enabled: z.boolean().default(false),
-  /** Card ID prefix (e.g. "CM" → CM-1, CM-2). */
-  prefix: z.string().default("CM"),
-  /** Allow agents to auto-claim matching cards. */
-  autoAssign: z.boolean().default(true),
-  /** Archive cards older than this (ms). Default: 30 days. */
-  archiveAfterMs: z.number().default(30 * 24 * 60 * 60 * 1000),
-}).optional();
+const KanbanConfigSchema = z.preprocess(
+  (v) => v ?? {},
+  z.object({
+    enabled: z.boolean().default(true),
+    /** Card ID prefix (e.g. "CM" → CM-1, CM-2). */
+    prefix: z.string().default("CM"),
+    /** Allow agents to auto-claim matching cards. */
+    autoAssign: z.boolean().default(true),
+    /** Archive cards older than this (ms). Default: 30 days. */
+    archiveAfterMs: z.number().default(30 * 24 * 60 * 60 * 1000),
+  }),
+).default({});
 
 const AcpConfigSchema = z.object({
   enabled: z.boolean().default(false),

package/src/connection.ts

@@ -269,6 +269,15 @@ export class Connection extends EventEmitter<ConnectionEvents> {
   private async onRawMessage(data: unknown) {
     this.lastReceivedAt = Date.now();
 
+    // Debug: log data type for unauthenticated connections to diagnose auth issues
+    if (!this.authenticated && this.role === "outbound") {
+      const dtype = Buffer.isBuffer(data) ? `Buffer(${(data as Buffer).length})` :
+        data instanceof ArrayBuffer ? `ArrayBuffer(${data.byteLength})` :
+        typeof data === "string" ? `string(${data.length})` :
+        `${data?.constructor?.name ?? typeof data}`;
+      debug("auth", `onRawMessage[outbound] dataType=${dtype}`);
+    }
+
     // Normalize non-Buffer binary types to Buffer.
     // Node.js 24+'s built-in WebSocket (undici) delivers binary frames as Blob
     // (binaryType "blob") or ArrayBuffer (binaryType "arraybuffer").
@@ -570,6 +579,7 @@ export class Connection extends EventEmitter<ConnectionEvents> {
       }
 
       // auth_ok (decrypted from binary envelope, or plaintext legacy)
+      debug("auth", `Outbound received frame type=${frame.type} (authenticated=${this.authenticated})`);
       if (frame.type === "auth_ok") {
         const ok = frame as AuthOk;
         this.remoteNodeId = ok.payload.nodeId;

package/src/device-info.ts

@@ -50,6 +50,15 @@ function resolveWorkspace(openclawConfig?: Record<string, unknown>): string | un
   return undefined;
 }
 
+function resolveClawmatrixVersion(): string | undefined {
+  try {
+    const raw = readFileSync(join(dirname(import.meta.url.replace("file://", "")), "..", "package.json"), "utf-8");
+    const pkg = JSON.parse(raw) as { version?: string };
+    return pkg.version;
+  } catch { /* best effort */ }
+  return undefined;
+}
+
 /** Collect device info once at startup. */
 export function collectDeviceInfo(openclawVersion?: string, openclawConfig?: Record<string, unknown>): DeviceInfo {
   const cpuList = cpus();
@@ -61,6 +70,7 @@ export function collectDeviceInfo(openclawVersion?: string, openclawConfig?: Rec
     totalMemoryMB: Math.round(totalmem() / (1024 * 1024)),
     hostname: hostname(),
     openclawVersion: resolveOpenclawVersion(openclawVersion),
+    clawmatrixVersion: resolveClawmatrixVersion(),
     cwd: process.cwd(),
     workspace: resolveWorkspace(openclawConfig),
   };

package/src/health-tracker.ts

@@ -55,6 +55,10 @@ export class HealthTracker {
   private readonly nodeId: string;
   private store: Store | null;
   private logReplicator: LogReplicator | null;
+  /** In-memory timestamp of when start() was called (survives store failures). */
+  private startedAt: number | null = null;
+  /** In-memory tracking of currently connected peers (timestamp of connection). */
+  private readonly connectedPeers = new Map<string, number>();
 
   constructor(opts: HealthTrackerOptions) {
     this.nodeId = opts.nodeId;
@@ -66,14 +70,23 @@ export class HealthTracker {
   setStore(store: Store, logReplicator?: LogReplicator) {
     this.store = store;
     this.logReplicator = logReplicator ?? this.logReplicator;
+    // Flush deferred events that occurred before store was available
+    if (this.startedAt !== null) {
+      this.recordEvent({ ts: this.startedAt, type: "start" });
+    }
+    for (const [peerId, ts] of this.connectedPeers) {
+      this.recordEvent({ ts, type: "peer_online", peer: peerId, via: "direct" });
+    }
   }
 
   async start() {
-    this.recordEvent({ ts: Date.now(), type: "start" });
+    this.startedAt = Date.now();
+    this.recordEvent({ ts: this.startedAt, type: "start" });
     debug(TAG, `health tracker started for node "${this.nodeId}"`);
   }
 
   async stop() {
+    this.startedAt = null;
     this.recordEvent({ ts: Date.now(), type: "stop" });
     debug(TAG, "health tracker stopped");
   }
@@ -98,10 +111,12 @@ export class HealthTracker {
   }
 
   recordPeerOnline(peerId: string, via: "direct" | "relay") {
+    this.connectedPeers.set(peerId, Date.now());
     this.recordEvent({ ts: Date.now(), type: "peer_online", peer: peerId, via });
   }
 
   recordPeerOffline(peerId: string, reason?: string) {
+    this.connectedPeers.delete(peerId);
     this.recordEvent({ ts: Date.now(), type: "peer_offline", peer: peerId, reason });
   }
 
@@ -143,6 +158,18 @@ export class HealthTracker {
 
     // Find observation gaps (periods where THIS node was down)
     const selfEvents = this.getEventsForNode(this.nodeId);
+    // Inject current in-memory session if not reflected in persisted events.
+    // This handles the case where the store wasn't ready when start() was called,
+    // or the start event failed to persist for any reason.
+    if (this.startedAt !== null) {
+      const hasCurrentStart = selfEvents.some(
+        (e) => e.type === "start" && e.ts === this.startedAt,
+      );
+      if (!hasCurrentStart) {
+        selfEvents.push({ ts: this.startedAt, type: "start" });
+        selfEvents.sort((a, b) => a.ts - b.ts);
+      }
+    }
     const gaps = this.getObservationGaps(selfEvents, startTs, endTs);
 
     // Build timeline for each node (including self)
@@ -154,12 +181,22 @@ export class HealthTracker {
     for (const ev of allEvents) {
       if (ev.peer) everConnected.add(ev.peer);
     }
+    // Include currently connected peers (in-memory, survives store failures)
+    for (const peerId of this.connectedPeers.keys()) {
+      everConnected.add(peerId);
+    }
+
+    const knownNodes = new Set(this.getKnownNodes());
+    // Always include self node
+    knownNodes.add(this.nodeId);
+    // Also include nodes we've observed via peer_online events
+    for (const peerId of everConnected) knownNodes.add(peerId);
 
-    const knownNodes = this.getKnownNodes();
     for (const nodeId of knownNodes) {
       if (nodeId !== this.nodeId && !everConnected.has(nodeId)) continue;
 
-      const events = this.getEventsForNode(nodeId);
+      // Reuse selfEvents (with injected in-memory start) for the self node
+      const events = nodeId === this.nodeId ? selfEvents : this.getEventsForNode(nodeId);
       const timeline = this.buildNodeTimeline(
         nodeId, events, startTs, endTs, bucketMs, bucketCount, gaps,
       );
@@ -181,12 +218,37 @@ export class HealthTracker {
     observerGaps: Array<[number, number]>,
   ): NodeTimeline | null {
     const sorted = [...events].sort((a, b) => a.ts - b.ts);
-    if (sorted.length === 0) return null;
 
-    const firstSeen = sorted[0]!.ts;
-    const lastSeen = sorted[sorted.length - 1]!.ts;
+    // For remote nodes, also consider peer observation intervals
+    const peerIntervals = nodeId !== this.nodeId
+      ? this.buildPeerIntervals(nodeId, startTs, endTs)
+      : [];
+
+    if (sorted.length === 0 && peerIntervals.length === 0) {
+      // For self node with no events (store not initialized), treat as currently online
+      if (nodeId === this.nodeId) {
+        const now = Date.now();
+        const buckets: BucketState[] = Array(bucketCount).fill("up");
+        return { nodeId, firstSeen: now, lastSeen: now, buckets, uptimeRatio: 1 };
+      }
+      return null;
+    }
 
-    const intervals = this.buildOnlineIntervals(nodeId, sorted, startTs, endTs);
+    // Determine firstSeen/lastSeen from both self-reported events and peer observations
+    let firstSeen = Infinity;
+    let lastSeen = -Infinity;
+    if (sorted.length > 0) {
+      firstSeen = sorted[0]!.ts;
+      lastSeen = sorted[sorted.length - 1]!.ts;
+    }
+    for (const [s, e] of peerIntervals) {
+      if (s < firstSeen) firstSeen = s;
+      if (e > lastSeen) lastSeen = e;
+    }
+
+    const intervals = nodeId !== this.nodeId
+      ? this.mergeIntervals([...this.buildSelfIntervals(sorted, startTs, endTs), ...peerIntervals])
+      : this.buildOnlineIntervals(nodeId, sorted, startTs, endTs);
 
     const buckets: BucketState[] = [];
     let totalOnline = 0;
@@ -280,13 +342,29 @@ export class HealthTracker {
     startTs: number,
     endTs: number,
   ): Array<[number, number]> {
-    if (!this.store) return [];
+    const relevantEvents: HealthEvent[] = [];
+
+    if (this.store) {
+      // Collect peer_online/peer_offline events about this node from ALL observers
+      const relevantRows = this.store.queryHealth({ peer: targetNodeId });
+      for (const r of relevantRows) {
+        if (r.type === "peer_online" || r.type === "peer_offline") {
+          relevantEvents.push({ ts: r.ts, type: r.type as HealthEvent["type"], peer: r.peer ?? undefined });
+        }
+      }
+    }
+
+    // Inject in-memory connected peer if not reflected in persisted events
+    const connectedAt = this.connectedPeers.get(targetNodeId);
+    if (connectedAt !== undefined) {
+      const hasRecentOnline = relevantEvents.some(
+        (e) => e.type === "peer_online" && e.ts === connectedAt,
+      );
+      if (!hasRecentOnline) {
+        relevantEvents.push({ ts: connectedAt, type: "peer_online", peer: targetNodeId });
+      }
+    }
 
-    // Collect peer_online/peer_offline events about this node from ALL observers
-    const relevantRows = this.store.queryHealth({ peer: targetNodeId });
-    const relevantEvents: HealthEvent[] = relevantRows
-      .filter(r => r.type === "peer_online" || r.type === "peer_offline")
-      .map(r => ({ ts: r.ts, type: r.type as HealthEvent["type"], peer: r.peer ?? undefined }));
     relevantEvents.sort((a, b) => a.ts - b.ts);
 
     const intervals: Array<[number, number]> = [];