npm - meshy-node - Versions diffs - 0.0.5 → 0.0.6 - Mend

meshy-node 0.0.5 → 0.0.6

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (11) hide show

package/dashboard/index.html CHANGED Viewed

@@ -5,7 +5,7 @@
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
     <title>Meshy Dashboard</title>
     <link rel="icon" type="image/svg+xml" href="data:image/svg+xml,<svg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 100 100'><text y='.9em' font-size='90'>&#x1F578;</text></svg>" />
-    <script type="module" crossorigin src="/assets/index-Cf2Ckzj8.js"></script>
+    <script type="module" crossorigin src="/assets/index-Br1FoGY0.js"></script>
     <link rel="stylesheet" crossorigin href="/assets/index-CS0F09J4.css">
   </head>
   <body>

package/main.cjs CHANGED Viewed

@@ -23672,6 +23672,10 @@ var NodeRegistry = class {
       endpoint: info.endpoint
     });
   }
+  upsertNode(info) {
+    this.nodes.set(info.id, { ...info });
+    this.store.upsertNode(info);
+  }
   removeNode(id) {
     this.nodes.delete(id);
     this.store.removeNode(id);
@@ -24092,6 +24096,44 @@ var TaskEngine = class {
     const tasks = this.store.getAllTasks(filter);
     return { tasks, total: tasks.length };
   }
+  importTasks(tasks) {
+    let created = 0;
+    let updated = 0;
+    for (const task of tasks) {
+      const existing = this.store.getTask(task.id);
+      if (!existing) {
+        this.store.createTask(task);
+        created++;
+        this.eventBus.emit("task.created", {
+          taskId: task.id,
+          title: task.title,
+          priority: task.priority
+        });
+        this.eventBus.emit("task.status", {
+          taskId: task.id,
+          status: task.status,
+          ...task.result ? { result: task.result } : {},
+          ...task.error ? { error: task.error } : {}
+        });
+        continue;
+      }
+      if (existing.updatedAt > task.updatedAt) {
+        continue;
+      }
+      const previousStatus = existing.status;
+      this.store.updateTask(task.id, task);
+      updated++;
+      if (task.status !== previousStatus) {
+        this.eventBus.emit("task.status", {
+          taskId: task.id,
+          status: task.status,
+          ...task.result ? { result: task.result } : {},
+          ...task.error ? { error: task.error } : {}
+        });
+      }
+    }
+    return { created, updated };
+  }
   updateTask(id, updates) {
     const existing = this.store.getTask(id);
     if (!existing) return null;
@@ -24789,11 +24831,67 @@ var HeartbeatMonitor = class {
   }
   // ── Leader: handle keepalive from follower ──────────────────────────
   handleKeepalive(req) {
-    const { nodeId, status, load, devtunnelEnabled, devtunnelEndpoint, previewOrigin, workDirFolders } = req;
+    const {
+      nodeId,
+      name,
+      endpoint,
+      status,
+      load,
+      capabilities,
+      transportType,
+      workDir,
+      devtunnelEnabled,
+      devtunnelEndpoint,
+      previewOrigin,
+      workDirFolders
+    } = req;
+    const existingNode = this.nodeRegistry.getNode(nodeId);
+    const normalizedName = name ?? existingNode?.name ?? nodeId;
+    const normalizedEndpoint = endpoint ?? existingNode?.endpoint ?? devtunnelEndpoint ?? "";
+    const normalizedCapabilities = capabilities ?? existingNode?.capabilities ?? [];
+    const currentCapabilities = existingNode?.capabilities ?? [];
     this.log.debug("keepalive received", { nodeId, status });
     this.followerMissedMap.set(nodeId, 0);
-    this.nodeRegistry.updateHeartbeat(nodeId, Date.now());
-    const node = this.nodeRegistry.getNode(nodeId);
+    let node = existingNode;
+    const now = Date.now();
+    if (!node) {
+      this.nodeRegistry.addNode({
+        id: nodeId,
+        name: normalizedName,
+        endpoint: normalizedEndpoint,
+        role: "follower",
+        status,
+        capabilities: normalizedCapabilities,
+        joinedAt: now,
+        lastHeartbeat: now,
+        ...transportType ? { transportType } : {},
+        ...workDir ? { workDir } : {},
+        ...devtunnelEnabled && devtunnelEndpoint ? { devtunnelEndpoint } : {},
+        ...previewOrigin ? { previewOrigin } : {},
+        ...workDirFolders ? { workDirFolders } : {}
+      });
+      this.log.info("keepalive restored missing follower", { nodeId, endpoint: normalizedEndpoint });
+      node = this.nodeRegistry.getNode(nodeId);
+    }
+    this.nodeRegistry.updateHeartbeat(nodeId, now);
+    node = this.nodeRegistry.getNode(nodeId);
+    if (node && normalizedEndpoint && node.endpoint !== normalizedEndpoint) {
+      this.nodeRegistry.updateEndpoint(nodeId, normalizedEndpoint);
+      node = this.nodeRegistry.getNode(nodeId);
+    }
+    if (node && (node.name !== normalizedName || node.transportType !== transportType || node.workDir !== workDir || currentCapabilities.length !== normalizedCapabilities.length || currentCapabilities.some((capability, index) => capability !== normalizedCapabilities[index]))) {
+      this.nodeRegistry.upsertNode({
+        ...node,
+        name: normalizedName,
+        endpoint: normalizedEndpoint || node.endpoint,
+        status,
+        lastHeartbeat: now,
+        capabilities: normalizedCapabilities,
+        ...transportType ? { transportType } : {},
+        ...workDir ? { workDir } : {}
+      });
+      node = this.nodeRegistry.getNode(nodeId);
+    }
     if (node && node.status === "offline") {
       this.nodeRegistry.updateStatus(nodeId, status);
       this.log.info("keepalive restored node", { nodeId, status });
@@ -24840,8 +24938,13 @@ var HeartbeatMonitor = class {
     const self = this.nodeRegistry.getSelf();
     const request = {
       nodeId: self.id,
+      name: self.name,
+      endpoint: self.endpoint,
       status: self.status,
       load: 0,
+      capabilities: self.capabilities,
+      transportType: self.transportType,
+      workDir: self.workDir,
       devtunnelEnabled: self.devtunnelEndpoint !== void 0,
       devtunnelEndpoint: self.devtunnelEndpoint,
       previewOrigin: self.previewOrigin,
@@ -26191,7 +26294,8 @@ ${joinErrors.map((e) => `  - ${e}`).join("\n")}`
       id: this.selfInfo.id,
       endpoint: this.selfInfo.endpoint,
       name: this.config.node.name,
-      capabilities: []
+      capabilities: [],
+      tasks: this.taskEngine.listTasks().tasks
     };
     if (this.selfInfo.devtunnelEndpoint) {
       joinBody.devtunnelEndpoint = this.selfInfo.devtunnelEndpoint;
@@ -26212,13 +26316,36 @@ ${joinErrors.map((e) => `  - ${e}`).join("\n")}`
       throw new Error(`Failed to join cluster via ${seedUrl}: ${response.status}`);
     }
     const data = await response.json();
-    for (const node of data.nodes) {
-      const existing = this.nodeRegistry.getNode(node.id);
-      if (!existing && node.id !== this.selfInfo.id) {
-        this.nodeRegistry.addNode(node);
-      }
+    this.applyClusterState(data.nodes, data.leaderId, data.term);
+  }
+  async leaveCluster() {
+    const leader = this.nodeRegistry.getLeader();
+    const leaderEndpoint = this.nodeRegistry.getLeaderEndpoint();
+    const self = this.nodeRegistry.getSelf();
+    if (!leader || !leaderEndpoint || leader.id === self.id) {
+      return;
     }
-    this.nodeRegistry.setLeader(data.leaderId, data.term);
+    try {
+      await fetch(`${leaderEndpoint}/api/cluster/leave`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ nodeId: self.id })
+      });
+    } catch {
+    }
+    const refreshedSelf = {
+      ...self,
+      role: "follower",
+      status: "online",
+      lastHeartbeat: Date.now(),
+      workDirFolders: listWorkDirFolders(this.getWorkDir())
+    };
+    this.selfInfo = refreshedSelf;
+    this.nodeRegistry.setSelf(refreshedSelf);
+    this.nodeRegistry.syncFromHeartbeat([refreshedSelf]);
+    this.nodeRegistry.clearLeader();
+    this.election.stepDown();
+    await this.election.startElection();
   }
   async stop() {
     if (!this.started) return;
@@ -26381,6 +26508,22 @@ ${joinErrors.map((e) => `  - ${e}`).join("\n")}`
     this.selfInfo.role = current.role;
     this.selfInfo.status = current.status;
   }
+  applyClusterState(nodes, leaderId, term) {
+    const remoteSelf = nodes.find((node) => node.id === this.selfInfo.id);
+    const nextSelf = {
+      ...this.selfInfo,
+      ...remoteSelf ?? {},
+      transportType: this.config.transport.type,
+      workDir: this.selfInfo.workDir,
+      workDirFolders: listWorkDirFolders(this.getWorkDir()),
+      ...this.selfInfo.devtunnelEndpoint ? { devtunnelEndpoint: this.selfInfo.devtunnelEndpoint } : {},
+      ...this.selfInfo.previewOrigin ? { previewOrigin: this.selfInfo.previewOrigin } : {}
+    };
+    this.selfInfo = nextSelf;
+    this.nodeRegistry.setSelf(nextSelf);
+    this.nodeRegistry.syncFromHeartbeat(nodes);
+    this.election.handleLeaderAnnounce({ leaderId, term });
+  }
   cloneTransportConfig(config) {
     return {
       type: config.type,
@@ -30611,12 +30754,33 @@ var NodeInfoSchema = external_exports.object({
   devtunnelEndpoint: external_exports.string().optional(),
   previewOrigin: external_exports.string().optional()
 });
+var JoinTaskSchema = external_exports.object({
+  id: external_exports.string(),
+  title: external_exports.string(),
+  description: external_exports.string(),
+  agent: external_exports.string(),
+  project: external_exports.string().nullable(),
+  effectiveProjectPath: external_exports.string().nullable(),
+  payload: external_exports.record(external_exports.unknown()),
+  status: external_exports.enum(["pending", "assigned", "running", "completed", "failed", "cancelled", "archived"]),
+  priority: external_exports.enum(["low", "normal", "high", "critical"]),
+  assignedTo: external_exports.string().nullable(),
+  assignedNodeName: external_exports.string().nullable().optional(),
+  createdBy: external_exports.string(),
+  result: external_exports.record(external_exports.unknown()).nullable(),
+  error: external_exports.string().nullable(),
+  retryCount: external_exports.number(),
+  maxRetries: external_exports.number(),
+  createdAt: external_exports.number(),
+  updatedAt: external_exports.number()
+});
 var JoinClusterBody = external_exports.object({
   id: external_exports.string().min(1),
   endpoint: external_exports.string().url(),
   name: external_exports.string().min(1),
   capabilities: external_exports.array(external_exports.string()).default([]),
-  devtunnelEndpoint: external_exports.string().url().optional()
+  devtunnelEndpoint: external_exports.string().url().optional(),
+  tasks: external_exports.array(JoinTaskSchema).default([])
 });
 var JoinClusterResponse = external_exports.object({
   clusterId: external_exports.string(),
@@ -30640,6 +30804,10 @@ var ElectionBody = external_exports.object({
   candidateId: external_exports.string(),
   term: external_exports.number().int().min(1)
 });
+var ConnectClusterBody = external_exports.object({
+  leaderEndpoint: external_exports.string().url(),
+  transport: external_exports.literal("devtunnel")
+});
 // ../../packages/api/src/schemas/nodes.ts
 var NodeInfoSchema2 = external_exports.object({
@@ -30707,6 +30875,7 @@ var TaskListResponse = external_exports.object({
     priority: external_exports.enum(["low", "normal", "high", "critical"]),
     assignedTo: external_exports.string().nullable(),
     assignedNodeName: external_exports.string().nullable().optional(),
+    assignedNodeAvailable: external_exports.boolean().optional(),
     createdBy: external_exports.string(),
     result: external_exports.record(external_exports.unknown()).nullable(),
     error: external_exports.string().nullable(),
@@ -30885,13 +31054,32 @@ function createErrorMiddleware() {
 // ../../packages/api/src/routes/cluster.ts
 var import_express = __toESM(require_express2(), 1);
+var CONNECTIVITY_TIMEOUT_MS = 8e3;
+async function verifyHealth(endpoint) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), CONNECTIVITY_TIMEOUT_MS);
+  try {
+    const response = await fetch(`${endpoint}/api/system/health`, {
+      signal: controller.signal
+    });
+    if (!response.ok) {
+      throw new Error(`health check returned ${response.status}`);
+    }
+  } catch (err) {
+    throw new Error(
+      `Failed to verify connectivity for ${endpoint}: ${err instanceof Error ? err.message : String(err)}`
+    );
+  } finally {
+    clearTimeout(timer);
+  }
+}
 function asyncHandler(fn) {
   return (req, res, next) => fn(req, res, next).catch(next);
 }
 function createClusterRoutes() {
   const router = (0, import_express.Router)();
   router.post("/join", asyncHandler(async (req, res) => {
-    const { nodeRegistry, election } = req.app.locals.deps;
+    const { nodeRegistry, election, taskEngine } = req.app.locals.deps;
     if (!election.isLeader()) {
       const leaderEndpoint = nodeRegistry.getLeaderEndpoint();
       res.status(421).json({
@@ -30922,6 +31110,7 @@ function createClusterRoutes() {
       ...body.devtunnelEndpoint && { devtunnelEndpoint: body.devtunnelEndpoint }
     };
     nodeRegistry.addNode(node);
+    taskEngine.importTasks(body.tasks ?? []);
     const clusterState = nodeRegistry.getClusterState();
     res.status(201).json({
       clusterId: clusterState.clusterId ?? nanoid(),
@@ -30930,13 +31119,50 @@ function createClusterRoutes() {
       nodes: clusterState.nodes
     });
   }));
+  router.post("/connect", asyncHandler(async (req, res) => {
+    const {
+      nodeRegistry,
+      joinCurrentNodeToCluster
+    } = req.app.locals.deps;
+    const body = ConnectClusterBody.parse(req.body);
+    if (!joinCurrentNodeToCluster) {
+      throw new MeshyError("VALIDATION_ERROR", "Join flow is not available on this node", 501);
+    }
+    await verifyHealth(body.leaderEndpoint);
+    await joinCurrentNodeToCluster(body.leaderEndpoint);
+    const self = nodeRegistry.getSelf();
+    const clusterState = nodeRegistry.getClusterState();
+    res.json({
+      ok: true,
+      transport: body.transport,
+      self,
+      leaderId: clusterState.leaderId,
+      term: clusterState.term,
+      nodes: clusterState.nodes
+    });
+  }));
   router.post("/leave", asyncHandler(async (req, res) => {
-    const { nodeRegistry, eventBus } = req.app.locals.deps;
+    const { nodeRegistry } = req.app.locals.deps;
     const { nodeId } = req.body;
     nodeRegistry.removeNode(nodeId);
-    eventBus.emit("node.left", { nodeId, reason: "left" });
     res.json({ ok: true });
   }));
+  router.post("/disconnect", asyncHandler(async (req, res) => {
+    const { leaveCurrentCluster, nodeRegistry } = req.app.locals.deps;
+    if (!leaveCurrentCluster) {
+      throw new MeshyError("VALIDATION_ERROR", "Leave flow is not available on this node", 501);
+    }
+    await leaveCurrentCluster();
+    const self = nodeRegistry.getSelf();
+    const clusterState = nodeRegistry.getClusterState();
+    res.json({
+      ok: true,
+      self,
+      leaderId: clusterState.leaderId,
+      term: clusterState.term,
+      nodes: clusterState.nodes
+    });
+  }));
   router.get("/state", asyncHandler(async (req, res) => {
     const { nodeRegistry, taskEngine } = req.app.locals.deps;
     const clusterState = nodeRegistry.getClusterState();
@@ -31826,7 +32052,7 @@ function createNodeRoutes() {
     res.json(node);
   }));
   router.delete("/:id", asyncHandler2(async (req, res) => {
-    const { nodeRegistry, eventBus, election } = req.app.locals.deps;
+    const { nodeRegistry, election } = req.app.locals.deps;
     if (!election.isLeader()) {
       throw new MeshyError("NOT_LEADER", "Only the leader node can delete nodes", 403);
     }
@@ -31835,7 +32061,6 @@ function createNodeRoutes() {
       throw new MeshyError("NODE_NOT_FOUND", `Node ${req.params.id} not found`, 404);
     }
     nodeRegistry.removeNode(req.params.id);
-    eventBus.emit("node.left", { nodeId: req.params.id, reason: "deleted" });
     res.json({ ok: true });
   }));
   router.post("/:id/devtunnel", asyncHandler2(async (req, res) => {
@@ -32042,17 +32267,15 @@ var ACTIVE_STATUSES = /* @__PURE__ */ new Set(["pending", "assigned", "running"]
 function asyncHandler3(fn) {
   return (req, res, next) => fn(req, res, next).catch(next);
 }
-function withAssignedNodeName(task, nodeRegistry) {
-  if (task.assignedNodeName || !task.assignedTo) {
+function withAssignedNodeMetadata(task, nodeRegistry) {
+  if (!task.assignedTo) {
     return task;
   }
   const node = nodeRegistry.getNode(task.assignedTo);
-  if (!node?.name) {
-    return task;
-  }
   return {
     ...task,
-    assignedNodeName: node.name
+    assignedNodeName: task.assignedNodeName ?? node?.name ?? null,
+    assignedNodeAvailable: node?.status !== "offline" && Boolean(node)
   };
 }
 function createTaskRoutes() {
@@ -32071,10 +32294,10 @@ function createTaskRoutes() {
     });
     if (body.assignTo) {
       const assigned = taskEngine.assignTask(task.id, body.assignTo);
-      res.status(201).json(withAssignedNodeName(assigned, nodeRegistry));
+      res.status(201).json(withAssignedNodeMetadata(assigned, nodeRegistry));
       return;
     }
-    res.status(201).json(withAssignedNodeName(task, nodeRegistry));
+    res.status(201).json(withAssignedNodeMetadata(task, nodeRegistry));
   }));
   router.get("/", asyncHandler3(async (req, res) => {
     const { taskEngine, nodeRegistry } = req.app.locals.deps;
@@ -32087,7 +32310,7 @@ function createTaskRoutes() {
     if (query.offset) filter.offset = query.offset;
     const result = taskEngine.listTasks(filter);
     res.json({
-      tasks: result.tasks.map((task) => withAssignedNodeName(task, nodeRegistry)),
+      tasks: result.tasks.map((task) => withAssignedNodeMetadata(task, nodeRegistry)),
       total: result.total
     });
   }));
@@ -32128,7 +32351,7 @@ function createTaskRoutes() {
     if (!task) {
       throw new MeshyError("TASK_NOT_FOUND", `Task ${req.params.id} not found`, 404);
     }
-    res.json(withAssignedNodeName(task, nodeRegistry));
+    res.json(withAssignedNodeMetadata(task, nodeRegistry));
   }));
   router.patch("/:id", asyncHandler3(async (req, res) => {
     const { taskEngine, nodeRegistry, logger: rootLogger } = req.app.locals.deps;
@@ -32144,7 +32367,7 @@ function createTaskRoutes() {
         currentStatus: existing.status,
         incomingStatus: updates.status
       });
-      res.json(withAssignedNodeName(existing, nodeRegistry));
+      res.json(withAssignedNodeMetadata(existing, nodeRegistry));
       return;
     }
     if (updates.status === "archived" && !ARCHIVABLE_STATUSES.has(existing.status)) {
@@ -32160,14 +32383,14 @@ function createTaskRoutes() {
         currentStatus: existing.status,
         incomingStatus: updates.status
       });
-      res.json(withAssignedNodeName(existing, nodeRegistry));
+      res.json(withAssignedNodeMetadata(existing, nodeRegistry));
       return;
     }
     const task = taskEngine.updateTask(req.params.id, updates);
     if (!task) {
       throw new MeshyError("TASK_NOT_FOUND", `Task ${req.params.id} not found`, 404);
     }
-    res.json(withAssignedNodeName(task, nodeRegistry));
+    res.json(withAssignedNodeMetadata(task, nodeRegistry));
   }));
   router.delete("/:id", asyncHandler3(async (req, res) => {
     const { taskEngine } = req.app.locals.deps;
@@ -32218,12 +32441,12 @@ function createTaskRoutes() {
     const { taskEngine, nodeRegistry } = req.app.locals.deps;
     const body = AssignTaskBody.parse(req.body);
     const task = taskEngine.assignTask(req.params.id, body.nodeId);
-    res.json(withAssignedNodeName(task, nodeRegistry));
+    res.json(withAssignedNodeMetadata(task, nodeRegistry));
   }));
   router.post("/:id/retry", asyncHandler3(async (req, res) => {
     const { taskEngine, nodeRegistry } = req.app.locals.deps;
     const task = taskEngine.retryTask(req.params.id);
-    res.json(withAssignedNodeName(task, nodeRegistry));
+    res.json(withAssignedNodeMetadata(task, nodeRegistry));
   }));
   router.get("/:id/logs", asyncHandler3(async (req, res) => {
     const { engineRegistry, taskEngine, nodeRegistry, logger: rootLogger } = req.app.locals.deps;
@@ -32308,26 +32531,18 @@ function createTaskRoutes() {
     }
     if (task.assignedTo && task.assignedTo !== nodeRegistry.getSelf()?.id) {
       const node = nodeRegistry.getNode(task.assignedTo);
-      const selfId = nodeRegistry.getSelf()?.id ?? null;
       if (!node || node.status === "offline") {
-        log.warn("assigned worker unavailable, resuming follow-up locally", {
+        log.warn("assigned worker unavailable for follow-up", {
           taskId: task.id,
-          assignedTo: task.assignedTo,
-          nodeFound: Boolean(node),
-          nodeStatus: node?.status,
-          reassignedTo: selfId
-        });
-        startLocalTaskFollowUp({
-          taskEngine,
-          engineRegistry,
-          logger: log
-        }, task, body.content, selfId, {
           assignedTo: task.assignedTo,
           nodeFound: Boolean(node),
           nodeStatus: node?.status
         });
-        res.json({ ok: true, reassigned: true });
-        return;
+        throw new MeshyError(
+          "NODE_OFFLINE",
+          `Task ${task.id} is unavailable because ${task.assignedNodeName ?? task.assignedTo} is no longer reachable`,
+          409
+        );
       }
       taskEngine.updateTask(task.id, { status: "running" });
       let workerEndpoint = node.endpoint;
@@ -33637,6 +33852,12 @@ async function main() {
     config: { apiKey: config.cluster.apiKey },
     workDir: meshyNode.getWorkDir(),
     persistNodeNamePreference: (name) => persistDefaultNodeName(config.storage.path, name),
+    joinCurrentNodeToCluster: async (leaderEndpoint) => {
+      await meshyNode.joinCluster(leaderEndpoint);
+    },
+    leaveCurrentCluster: async () => {
+      await meshyNode.leaveCluster();
+    },
     switchTransport: async (type) => {
       return meshyNode.switchTransport(type);
     },

package/package.json CHANGED Viewed

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