meshy-node 0.0.8 → 0.0.9

package/README.md

@@ -1,6 +1,6 @@
 # meshy-node
 
-Version: 0.0.8
+Version: 0.0.9
 
 This package contains the built Meshy standalone node runtime only.
 It intentionally excludes repository source files and TypeScript sources.

package/main.cjs

@@ -25022,12 +25022,24 @@ function listWorkDirFolders(workDir) {
 
 // ../../packages/core/src/heartbeat.ts
 var MISSED_HEARTBEAT_THRESHOLD = 3;
+var DEFAULT_KEEPALIVE_INTERVAL_MS = 3e3;
+var HEARTBEAT_SUCCESS_LOG_INTERVAL_MS = 6e4;
+var HEARTBEAT_FAILURE_LOG_INTERVAL_MS = 1e4;
 function formatError(error) {
   return error instanceof Error ? error.message : String(error);
 }
 function truncateForLog(value, max = 240) {
   return !value || value.length <= max ? value : `${value.slice(0, max - 3)}...`;
 }
+function describeControlRequest(request) {
+  return {
+    requestId: request.requestId,
+    kind: request.kind,
+    taskId: request.taskId,
+    path: request.path,
+    enabled: request.enabled
+  };
+}
 var HeartbeatMonitor = class {
   constructor(nodeRegistry, election, eventBus, config, logger) {
     this.nodeRegistry = nodeRegistry;
@@ -25080,6 +25092,8 @@ var HeartbeatMonitor = class {
   pendingControlResponses = /* @__PURE__ */ new Map();
   /** Follower-side callback for executing keepalive-delivered control requests. */
   controlRequestHandler;
+  /** Throttle repetitive heartbeat / keepalive logs while preserving periodic visibility. */
+  throttledLogs = /* @__PURE__ */ new Map();
   /** Set the callback used to query tasks assigned to a follower for pull-based dispatch. */
   setGetAssignedTasks(fn) {
     this.getAssignedTasks = fn;
@@ -25120,10 +25134,9 @@ var HeartbeatMonitor = class {
     const queued = this.queuedControlRequests.get(nodeId) ?? [];
     queued.push(fullRequest);
     this.queuedControlRequests.set(nodeId, queued);
-    this.log.info("queued control request for keepalive delivery", {
+    this.log.info("queued keepalive control request", {
       nodeId,
-      requestId: fullRequest.requestId,
-      kind: fullRequest.kind
+      ...describeControlRequest(fullRequest)
     });
     return new Promise((resolve10, reject) => {
       const timeoutId = setTimeout(() => {
@@ -25132,6 +25145,7 @@ var HeartbeatMonitor = class {
       }, timeoutMs);
       this.pendingControlResponses.set(fullRequest.requestId, {
         nodeId,
+        kind: fullRequest.kind,
         resolve: resolve10,
         reject,
         timeoutId
@@ -25149,6 +25163,13 @@ var HeartbeatMonitor = class {
     }
     clearTimeout(pending.timeoutId);
     this.pendingControlResponses.delete(response.requestId);
+    this.log.info("received keepalive control response", {
+      requestId: response.requestId,
+      nodeId: pending.nodeId,
+      kind: pending.kind,
+      ok: response.ok,
+      statusCode: response.statusCode
+    });
     pending.resolve(response);
     return true;
   }
@@ -25211,7 +25232,7 @@ var HeartbeatMonitor = class {
           body: JSON.stringify(request)
         }, void 0, {
           onAttempt: ({ attempt, endpoint: targetEndpoint, totalEndpoints, timeoutMs }) => {
-            this.log.info("sending heartbeat request", {
+            this.log.debug("sending heartbeat request", {
               nodeId: node.id,
               endpoint: targetEndpoint,
               attempt,
@@ -25221,16 +25242,22 @@ var HeartbeatMonitor = class {
             });
           },
           onError: ({ attempt, endpoint: targetEndpoint, error, totalEndpoints }) => {
-            this.log.warn("heartbeat request attempt failed", {
-              nodeId: node.id,
-              endpoint: targetEndpoint,
-              attempt,
-              totalEndpoints,
-              error: formatError(error)
-            });
+            this.logWithThrottle(
+              "warn",
+              `heartbeat-attempt-failure:${node.id}`,
+              HEARTBEAT_FAILURE_LOG_INTERVAL_MS,
+              "heartbeat request attempt failed",
+              {
+                nodeId: node.id,
+                endpoint: targetEndpoint,
+                attempt,
+                totalEndpoints,
+                error: formatError(error)
+              }
+            );
           },
           onResponse: ({ attempt, endpoint: targetEndpoint, response: heartbeatResponse, totalEndpoints }) => {
-            this.log.info("heartbeat response received", {
+            this.log.debug("heartbeat response received", {
               nodeId: node.id,
               endpoint: targetEndpoint,
               attempt,
@@ -25255,13 +25282,19 @@ var HeartbeatMonitor = class {
           if (result.status !== node.status) {
             this.nodeRegistry.updateStatus(node.id, result.status);
           }
-          this.log.info("heartbeat response applied", {
-            nodeId: node.id,
-            endpoint,
-            reportedStatus: result.status,
-            load: result.load,
-            workDirFolders: result.workDirFolders?.length ?? 0
-          });
+          this.logWithThrottle(
+            "info",
+            `heartbeat-success:${node.id}`,
+            HEARTBEAT_SUCCESS_LOG_INTERVAL_MS,
+            "heartbeat response applied",
+            {
+              nodeId: node.id,
+              endpoint,
+              reportedStatus: result.status,
+              load: result.load,
+              workDirFolders: result.workDirFolders?.length ?? 0
+            }
+          );
           return;
         }
         const body = truncateForLog(await response.text().catch(() => void 0));
@@ -25401,6 +25434,15 @@ var HeartbeatMonitor = class {
     if (controlRequests.length > 0) {
       this.queuedControlRequests.delete(nodeId);
     }
+    if (dispatchedTasks.length > 0 || followUpMessages.length > 0 || controlRequests.length > 0) {
+      this.log.info("keepalive delivering queued work", {
+        nodeId,
+        dispatchedTaskCount: dispatchedTasks.length,
+        followUpCount: followUpMessages.length,
+        controlRequestCount: controlRequests.length,
+        controlRequestKinds: controlRequests.map((request) => request.kind)
+      });
+    }
     const response = {
       leaderId: self.id,
       term: this.election.getCurrentTerm(),
@@ -25438,7 +25480,7 @@ var HeartbeatMonitor = class {
       previewOrigin: self.previewOrigin,
       workDirFolders: self.workDir ? listWorkDirFolders(self.workDir) : void 0
     };
-    this.log.info("sending keepalive request", {
+    this.log.debug("sending keepalive request", {
       nodeId: self.id,
       leaderEndpoint,
       status: self.status,
@@ -25453,14 +25495,22 @@ var HeartbeatMonitor = class {
       }));
       if (response.ok) {
         const result = await response.json();
-        this.log.info("keepalive response received", {
-          leaderId: result.leaderId,
-          term: result.term,
-          nodeCount: result.clusterState.nodes.length,
-          dispatchedTaskCount: result.dispatchedTasks?.length ?? 0,
-          followUpCount: result.followUpMessages?.length ?? 0,
-          controlRequestCount: result.controlRequests?.length ?? 0
-        });
+        const hasQueuedWork = (result.dispatchedTasks?.length ?? 0) > 0 || (result.followUpMessages?.length ?? 0) > 0 || (result.controlRequests?.length ?? 0) > 0;
+        this.logWithThrottle(
+          "info",
+          `keepalive-success:${leaderEndpoint}`,
+          HEARTBEAT_SUCCESS_LOG_INTERVAL_MS,
+          "keepalive response received",
+          {
+            leaderId: result.leaderId,
+            term: result.term,
+            nodeCount: result.clusterState.nodes.length,
+            dispatchedTaskCount: result.dispatchedTasks?.length ?? 0,
+            followUpCount: result.followUpMessages?.length ?? 0,
+            controlRequestCount: result.controlRequests?.length ?? 0
+          },
+          hasQueuedWork
+        );
         this.lastHeartbeatTime = Date.now();
         this.missedCount = 0;
         this.nodeRegistry.setLeader(result.leaderId, result.term);
@@ -25485,22 +25535,39 @@ var HeartbeatMonitor = class {
           }
         }
         if (result.controlRequests && result.controlRequests.length > 0) {
+          this.log.info("processing keepalive control requests", {
+            leaderEndpoint,
+            controlRequestCount: result.controlRequests.length,
+            controlRequestKinds: result.controlRequests.map((request2) => request2.kind)
+          });
           await Promise.all(result.controlRequests.map(
             (request2) => this.processControlRequest(leaderEndpoint, request2)
           ));
         }
       } else {
-        this.log.warn("keepalive request returned non-ok response", {
-          leaderEndpoint,
-          statusCode: response.status,
-          body: truncateForLog(await response.text().catch(() => void 0))
-        });
+        this.logWithThrottle(
+          "warn",
+          `keepalive-failure:${leaderEndpoint}`,
+          HEARTBEAT_FAILURE_LOG_INTERVAL_MS,
+          "keepalive request returned non-ok response",
+          {
+            leaderEndpoint,
+            statusCode: response.status,
+            body: truncateForLog(await response.text().catch(() => void 0))
+          }
+        );
       }
     } catch (err) {
-      this.log.warn("keepalive request failed", {
-        leaderEndpoint,
-        error: formatError(err)
-      });
+      this.logWithThrottle(
+        "warn",
+        `keepalive-failure:${leaderEndpoint}`,
+        HEARTBEAT_FAILURE_LOG_INTERVAL_MS,
+        "keepalive request failed",
+        {
+          leaderEndpoint,
+          error: formatError(err)
+        }
+      );
     }
   }
   // ── Accessors ───────────────────────────────────────────────────────
@@ -25547,9 +25614,10 @@ var HeartbeatMonitor = class {
     this.startKeepalive();
   }
   startKeepalive() {
+    const keepaliveInterval = Math.min(this.config.heartbeatInterval, DEFAULT_KEEPALIVE_INTERVAL_MS);
     this.keepaliveTimer = setInterval(() => {
       void this.sendKeepalive();
-    }, this.config.heartbeatInterval);
+    }, keepaliveInterval);
   }
   resetFollowerTimer() {
     if (this.followerTimer !== null) {
@@ -25575,16 +25643,22 @@ var HeartbeatMonitor = class {
     const newCount = current + 1;
     this.followerMissedMap.set(node.id, newCount);
     const everReached = this.followerEverReachedMap.get(node.id) ?? false;
-    this.log.warn("recorded heartbeat miss", {
-      nodeId: node.id,
-      misses: newCount,
-      everReached,
-      endpoint: details.endpoint,
-      statusCode: details.statusCode,
-      reason: details.reason,
-      error: details.error,
-      body: details.body
-    });
+    this.logWithThrottle(
+      "warn",
+      `heartbeat-miss:${node.id}`,
+      HEARTBEAT_FAILURE_LOG_INTERVAL_MS,
+      "recorded heartbeat miss",
+      {
+        nodeId: node.id,
+        misses: newCount,
+        everReached,
+        endpoint: details.endpoint,
+        statusCode: details.statusCode,
+        reason: details.reason,
+        error: details.error,
+        body: details.body
+      }
+    );
     if (newCount >= MISSED_HEARTBEAT_THRESHOLD) {
       const freshNode = this.nodeRegistry.getNode(node.id);
       if (freshNode) {
@@ -25634,6 +25708,10 @@ var HeartbeatMonitor = class {
     }
   }
   async processControlRequest(leaderEndpoint, request) {
+    this.log.info("processing keepalive control request", {
+      leaderEndpoint,
+      ...describeControlRequest(request)
+    });
     let response;
     if (!this.controlRequestHandler) {
       response = {
@@ -25668,6 +25746,12 @@ var HeartbeatMonitor = class {
         };
       }
     }
+    this.log.info("completed keepalive control request", {
+      leaderEndpoint,
+      ...describeControlRequest(request),
+      ok: response.ok,
+      statusCode: response.statusCode
+    });
     try {
       const res = await fetch(`${leaderEndpoint}/api/worker/control-response`, applyRequestAuthHeaders({
         method: "POST",
@@ -25691,6 +25775,21 @@ var HeartbeatMonitor = class {
       });
     }
   }
+  logWithThrottle(level, key, intervalMs, message, data, force = false) {
+    const now = Date.now();
+    const existing = this.throttledLogs.get(key);
+    if (existing && !force && now - existing.lastLoggedAt < intervalMs) {
+      existing.suppressedCount += 1;
+      return;
+    }
+    const mergedData = existing && existing.suppressedCount > 0 ? { ...data, suppressedCount: existing.suppressedCount } : data;
+    this.throttledLogs.set(key, { lastLoggedAt: now, suppressedCount: 0 });
+    if (level === "info") {
+      this.log.info(message, mergedData);
+      return;
+    }
+    this.log.warn(message, mergedData);
+  }
 };
 
 // ../../packages/core/src/data-router.ts
@@ -32594,7 +32693,16 @@ async function createPreviewSessionPayload(deps, taskId, entryPath) {
   };
 }
 async function executeWorkerControlRequest(deps, request) {
+  const log = deps.logger.child("worker-control");
+  log.info("received worker control request", {
+    requestId: request.requestId,
+    kind: request.kind,
+    taskId: request.taskId,
+    path: request.path,
+    enabled: request.enabled
+  });
   try {
+    let response;
     switch (request.kind) {
       case "devtunnel": {
         assertCanChangeNodeDevTunnel(deps.taskEngine, deps.nodeRegistry.getSelf().id);
@@ -32603,22 +32711,24 @@ async function executeWorkerControlRequest(deps, request) {
             throw new MeshyError("VALIDATION_ERROR", "DevTunnel control not available", 501);
           }
           const devtunnelEndpoint = await deps.enableDevTunnel();
-          return jsonResponse(request.requestId, 200, {
+          response = jsonResponse(request.requestId, 200, {
             ok: true,
             enabled: true,
             devtunnelEndpoint,
             dashboardOrigin: deps.nodeRegistry.getSelf().dashboardOrigin
           });
+          break;
         }
         if (!deps.disableDevTunnel) {
           throw new MeshyError("VALIDATION_ERROR", "DevTunnel control not available", 501);
         }
         await deps.disableDevTunnel();
-        return jsonResponse(request.requestId, 200, {
+        response = jsonResponse(request.requestId, 200, {
           ok: true,
           enabled: false,
           dashboardOrigin: deps.nodeRegistry.getSelf().dashboardOrigin
         });
+        break;
       }
       case "task-cancel": {
         const taskId = request.taskId ?? "";
@@ -32630,7 +32740,7 @@ async function executeWorkerControlRequest(deps, request) {
           missingOk: true,
           terminalOk: true
         });
-        return jsonResponse(request.requestId, 200, {
+        response = jsonResponse(request.requestId, 200, {
           ok: true,
           taskId,
           cancelled: result.cancelled,
@@ -32638,11 +32748,12 @@ async function executeWorkerControlRequest(deps, request) {
           missing: result.missing,
           terminal: result.terminal
         });
+        break;
       }
       case "task-output-summary": {
         const task = getTask(deps.taskEngine, request.taskId ?? "");
         if (!task.effectiveProjectPath) {
-          return jsonResponse(request.requestId, 200, {
+          response = jsonResponse(request.requestId, 200, {
             taskId: task.id,
             requestedProject: task.project,
             effectiveProjectPath: null,
@@ -32650,8 +32761,9 @@ async function executeWorkerControlRequest(deps, request) {
             available: false,
             summary: null
           });
+          break;
         }
-        return jsonResponse(request.requestId, 200, {
+        response = jsonResponse(request.requestId, 200, {
           taskId: task.id,
           requestedProject: task.project,
           effectiveProjectPath: task.effectiveProjectPath,
@@ -32659,15 +32771,17 @@ async function executeWorkerControlRequest(deps, request) {
           available: true,
           summary: getOutputSummary(task.effectiveProjectPath)
         });
+        break;
       }
       case "task-output-tree": {
         const rootPath = getTaskOutputRoot(deps.taskEngine, request.taskId ?? "");
         try {
-          return jsonResponse(request.requestId, 200, {
+          response = jsonResponse(request.requestId, 200, {
             rootPath,
             currentPath: request.path ?? ".",
             entries: listDirectory(rootPath, request.path ?? ".")
           });
+          break;
         } catch (err) {
           if (err instanceof Error && err.message === "Path traversal detected") {
             throw new MeshyError("VALIDATION_ERROR", "Invalid directory path", 400);
@@ -32679,10 +32793,11 @@ async function executeWorkerControlRequest(deps, request) {
         const rootPath = getTaskOutputRoot(deps.taskEngine, request.taskId ?? "");
         try {
           const filePath = request.path ?? "";
-          return jsonResponse(request.requestId, 200, {
+          response = jsonResponse(request.requestId, 200, {
             ...readFileContent(rootPath, filePath),
             downloadUrl: `/api/tasks/${request.taskId}/output/download?path=${encodeURIComponent(filePath)}`
           });
+          break;
         } catch (err) {
           if (err instanceof Error && err.message === "Path traversal detected") {
             throw new MeshyError("VALIDATION_ERROR", "Invalid file path", 400);
@@ -32702,11 +32817,12 @@ async function executeWorkerControlRequest(deps, request) {
           }
           const { mimeType } = classifyFile(absolutePath);
           const fileName = path13.basename(absolutePath).replace(/"/g, "");
-          return binaryResponse(request.requestId, 200, fs12.readFileSync(absolutePath), {
+          response = binaryResponse(request.requestId, 200, fs12.readFileSync(absolutePath), {
             "Content-Type": mimeType,
             "Content-Disposition": `inline; filename="${fileName}"`,
             "Cache-Control": "no-cache"
           });
+          break;
         } catch (err) {
           if (err instanceof MeshyError) throw err;
           if (err instanceof Error && err.message === "Path traversal detected") {
@@ -32717,18 +32833,41 @@ async function executeWorkerControlRequest(deps, request) {
       }
       case "task-output-diff": {
         const rootPath = getTaskOutputRoot(deps.taskEngine, request.taskId ?? "");
-        return jsonResponse(request.requestId, 200, getGitDiff(rootPath));
+        response = jsonResponse(request.requestId, 200, getGitDiff(rootPath));
+        break;
       }
       case "task-preview-session": {
-        return jsonResponse(
+        response = jsonResponse(
           request.requestId,
           200,
           await createPreviewSessionPayload(deps, request.taskId ?? "", request.path)
         );
+        break;
       }
     }
+    log.info("completed worker control request", {
+      requestId: request.requestId,
+      kind: request.kind,
+      taskId: request.taskId,
+      path: request.path,
+      enabled: request.enabled,
+      ok: response.ok,
+      statusCode: response.statusCode
+    });
+    return response;
   } catch (err) {
-    return errorResponse(request.requestId, err);
+    const response = errorResponse(request.requestId, err);
+    log.warn("worker control request failed", {
+      requestId: request.requestId,
+      kind: request.kind,
+      taskId: request.taskId,
+      path: request.path,
+      enabled: request.enabled,
+      ok: response.ok,
+      statusCode: response.statusCode,
+      error: err instanceof Error ? err.message : String(err)
+    });
+    return response;
   }
 }
 function sendWorkerControlResponse(res, response) {
@@ -33806,13 +33945,13 @@ function createWorkerRoutes() {
     const { heartbeat, logger: rootLogger } = req.app.locals.deps;
     const log = rootLogger.child("worker/heartbeat");
     const body = req.body;
-    log.info("received worker heartbeat API call", {
+    log.debug("received worker heartbeat API call", {
       leaderId: body.leaderId,
       term: body.term,
       nodeCount: body.clusterState?.nodes?.length ?? 0
     });
     const response = heartbeat.handleHeartbeat(body);
-    log.info("completed worker heartbeat API call", {
+    log.debug("completed worker heartbeat API call", {
       nodeId: response.nodeId,
       status: response.status,
       load: response.load
@@ -33823,13 +33962,13 @@ function createWorkerRoutes() {
     const { heartbeat, logger: rootLogger } = req.app.locals.deps;
     const log = rootLogger.child("worker/keepalive");
     const body = req.body;
-    log.info("received worker keepalive API call", {
+    log.debug("received worker keepalive API call", {
       nodeId: body.nodeId,
       status: body.status,
       endpoint: body.endpoint
     });
     const response = heartbeat.handleKeepalive(body);
-    log.info("completed worker keepalive API call", {
+    log.debug("completed worker keepalive API call", {
       leaderId: response.leaderId,
       term: response.term,
       nodeCount: response.clusterState.nodes.length,
@@ -34467,7 +34606,7 @@ function createDefaultConfig(storagePath = resolveDefaultStoragePath(), nodeName
   return {
     node: { name: nodeName, port: DEFAULT_NODE_PORT },
     transport: { type: "direct" },
-    cluster: { seeds: [], heartbeatInterval: 12e3, electionTimeout: 36e3, apiKey: "" },
+    cluster: { seeds: [], heartbeatInterval: 3e3, electionTimeout: 36e3, apiKey: "" },
     storage: { path: storagePath }
   };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "meshy-node",
-  "version": "0.0.8",
+  "version": "0.0.9",
   "private": false,
   "description": "Standalone Meshy node package with bundled runtime and dashboard assets.",
   "type": "commonjs",