npm - meshy-node - Versions diffs - 0.5.6 → 0.5.7 - Mend

meshy-node 0.5.6 → 0.5.7

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 (19) hide show

package/dashboard/assets/{play-DQGsm6yq.js → play-BR1-G2AM.js} RENAMED Viewed

@@ -1,4 +1,4 @@
-import{c as a}from"./index-nG4cAWuh.js";/**
+import{c as a}from"./index-DX2JBoPo.js";/**
  * @license lucide-react v1.7.0 - ISC
  *
  * This source code is licensed under the ISC license.

package/dashboard/index.html CHANGED Viewed

@@ -5,8 +5,8 @@
     <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-nG4cAWuh.js"></script>
-    <link rel="stylesheet" crossorigin href="/assets/index-DgDWjVGo.css">
+    <script type="module" crossorigin src="/assets/index-DX2JBoPo.js"></script>
+    <link rel="stylesheet" crossorigin href="/assets/index-BlCzIaoB.css">
   </head>
   <body>
     <div id="root"></div>

package/main.cjs CHANGED Viewed

@@ -52275,6 +52275,7 @@ function normalizeDevBoxMetadata(devbox) {
     locationInUri: normalizeString(devbox?.locationInUri),
     poolName: normalizeString(devbox?.poolName),
     scope: normalizeString(devbox?.scope),
+    alwaysOnline: devbox?.alwaysOnline === true,
     lastStatus: normalizeString(devbox?.lastStatus),
     checkedAt: typeof devbox?.checkedAt === "number" && Number.isFinite(devbox.checkedAt) ? devbox.checkedAt : void 0,
     operationId: normalizeString(devbox?.operationId)
@@ -52356,6 +52357,7 @@ function pickDevBoxConfig(devbox) {
   if (devbox.locationInUri) subset.locationInUri = devbox.locationInUri;
   if (devbox.poolName) subset.poolName = devbox.poolName;
   if (devbox.scope) subset.scope = devbox.scope;
+  if (devbox.alwaysOnline !== void 0) subset.alwaysOnline = devbox.alwaysOnline;
   return subset;
 }
 function persistNodeStartupTransport(storagePath, transport) {
@@ -54039,6 +54041,7 @@ function getPublicTaskUpdates(updates, updatedAt) {
   if (updates.description !== void 0) publicUpdates.description = updates.description;
   if (updates.priority !== void 0) publicUpdates.priority = updates.priority;
   if (updates.status !== void 0) publicUpdates.status = updates.status;
+  if (updates.queuedMessages !== void 0) publicUpdates.queuedMessages = updates.queuedMessages;
   if (updates.assignedTo !== void 0) publicUpdates.assignedTo = updates.assignedTo;
   if (updates.assignedNodeName !== void 0) publicUpdates.assignedNodeName = updates.assignedNodeName;
   if (updates.result !== void 0) publicUpdates.result = updates.result;
@@ -54221,6 +54224,61 @@ var TaskEngine = class {
     });
     return true;
   }
+  enqueueTaskMessage(taskId, content) {
+    const task = this.store.getTask(taskId);
+    if (!task) {
+      throw new MeshyError("TASK_NOT_FOUND", `Task ${taskId} not found`, 404);
+    }
+    if (task.status !== "running") {
+      throw new MeshyError(
+        "VALIDATION_ERROR",
+        `Task ${taskId} is not running (status: ${task.status})`,
+        400
+      );
+    }
+    const now = Date.now();
+    const queuedMessages = [
+      ...task.queuedMessages ?? [],
+      { id: (0, import_node_crypto5.randomUUID)(), content, createdAt: now }
+    ];
+    const updated = this.store.updateTask(taskId, { queuedMessages, updatedAt: now });
+    this.eventBus.emit("task.updated", {
+      taskId,
+      updates: { queuedMessages, updatedAt: now }
+    });
+    return updated;
+  }
+  dequeueTaskMessage(taskId) {
+    const task = this.store.getTask(taskId);
+    if (!task) {
+      throw new MeshyError("TASK_NOT_FOUND", `Task ${taskId} not found`, 404);
+    }
+    const [message, ...queuedMessages] = task.queuedMessages ?? [];
+    if (!message) return null;
+    const now = Date.now();
+    const updated = this.store.updateTask(taskId, { queuedMessages, updatedAt: now });
+    this.eventBus.emit("task.updated", {
+      taskId,
+      updates: { queuedMessages, updatedAt: now }
+    });
+    return { task: updated, message };
+  }
+  removeQueuedTaskMessage(taskId, messageId) {
+    const task = this.store.getTask(taskId);
+    if (!task) {
+      throw new MeshyError("TASK_NOT_FOUND", `Task ${taskId} not found`, 404);
+    }
+    const currentQueue = task.queuedMessages ?? [];
+    const queuedMessages = currentQueue.filter((message) => message.id !== messageId);
+    if (queuedMessages.length === currentQueue.length) return null;
+    const now = Date.now();
+    const updated = this.store.updateTask(taskId, { queuedMessages, updatedAt: now });
+    this.eventBus.emit("task.updated", {
+      taskId,
+      updates: { queuedMessages, updatedAt: now }
+    });
+    return updated;
+  }
   // ── Dispatch failure ─────────────────────────────────────────────────
   /**
    * Handle a dispatch failure for a task that is still in `assigned` status.
@@ -58240,6 +58298,7 @@ var NodeDevBoxInfoSchema = external_exports.object({
   locationInUri: external_exports.string().optional(),
   poolName: external_exports.string().optional(),
   scope: external_exports.string().optional(),
+  alwaysOnline: external_exports.boolean().optional(),
   lastStatus: external_exports.string().optional(),
   checkedAt: external_exports.number().optional(),
   operationId: external_exports.string().optional()
@@ -58535,6 +58594,11 @@ var TaskListResponse = external_exports.object({
     branch: external_exports.string().nullable().optional(),
     conversationKind: external_exports.enum(TASK_CONVERSATION_KIND_OPTIONS).optional(),
     payload: external_exports.record(external_exports.unknown()),
+    queuedMessages: external_exports.array(external_exports.object({
+      id: external_exports.string(),
+      content: external_exports.array(external_exports.record(external_exports.unknown())).min(1),
+      createdAt: external_exports.number()
+    })).optional(),
     status: external_exports.enum(["pending", "assigned", "running", "completed", "failed", "cancelled", "archived"]),
     priority: external_exports.enum(["low", "normal", "high", "critical"]),
     assignedTo: external_exports.string().nullable(),
@@ -58937,6 +59001,7 @@ var import_express = __toESM(require_express2(), 1);
 var sharedMcpControl;
 var DEFAULT_START_POLL_INTERVAL_MS = 1e4;
 var DEFAULT_START_TIMEOUT_MS = 15 * 6e4;
+var ALWAYS_ONLINE_STARTABLE_DEVBOX_STATUSES = /* @__PURE__ */ new Set(["hibernated", "stopped"]);
 function getDevBoxControl(deps) {
   if (deps.devBoxControl) return deps.devBoxControl;
   sharedMcpControl ??= new McpDevBoxControl(deps.logger);
@@ -58952,6 +59017,7 @@ function mergeDevBoxInfo(current, next) {
     locationInUri: merged.locationInUri,
     poolName: merged.poolName,
     scope: merged.scope,
+    alwaysOnline: merged.alwaysOnline,
     lastStatus: merged.lastStatus,
     checkedAt: merged.checkedAt,
     operationId: merged.operationId
@@ -59022,7 +59088,14 @@ async function waitForNodeDevBoxRunning(deps, nodeId, initial, options) {
   }
 }
 function isRunningDevBoxStatus(status) {
-  return status?.trim().toLowerCase().replace(/[\s_-]+/gu, "") === "running";
+  return normalizeDevBoxStatus(status) === "running";
+}
+function isAlwaysOnlineStartableDevBoxStatus(status) {
+  const normalized = normalizeDevBoxStatus(status);
+  return Boolean(normalized && ALWAYS_ONLINE_STARTABLE_DEVBOX_STATUSES.has(normalized));
+}
+function normalizeDevBoxStatus(status) {
+  return status?.trim().toLowerCase().replace(/[\s_-]+/gu, "");
 }
 function sleep(ms) {
   return new Promise((resolve14) => {
@@ -63666,29 +63739,6 @@ async function cancelRemoteTaskExecution(deps) {
   return response.ok ? null : response;
 }
-// ../../packages/api/src/tasks/task-follow-up.ts
-function startLocalTaskFollowUp(deps, task, content, assignedTo, metadata) {
-  const engine = deps.engineRegistry.get(task.agent);
-  if (!engine) {
-    throw new MeshyError("VALIDATION_ERROR", `Engine not registered for agent: ${task.agent}`, 400);
-  }
-  deps.taskEngine.updateTask(task.id, {
-    status: "running",
-    assignedTo
-  });
-  try {
-    engine.sendMessage(task.id, content);
-  } catch (err) {
-    restoreTaskState(deps.taskEngine, task);
-    deps.logger.warn("failed to start local follow-up execution", {
-      taskId: task.id,
-      ...metadata,
-      error: err instanceof Error ? err.message : String(err)
-    });
-    throw err;
-  }
-}
 // ../../packages/api/src/tasks/task-session-import.ts
 var TASK_IMPORT_PROXY_TIMEOUT_MS = 1e4;
 function buildImportedSessionTitle(agent, sessionId) {
@@ -63992,6 +64042,153 @@ async function sendTaskLogsResponse(req, res, taskId) {
   res.json(local);
 }
+// ../../packages/api/src/tasks/task-follow-up.ts
+function startLocalTaskFollowUp(deps, task, content, assignedTo, metadata) {
+  const engine = deps.engineRegistry.get(task.agent);
+  if (!engine) {
+    throw new MeshyError("VALIDATION_ERROR", `Engine not registered for agent: ${task.agent}`, 400);
+  }
+  deps.taskEngine.updateTask(task.id, {
+    status: "running",
+    assignedTo
+  });
+  try {
+    engine.sendMessage(task.id, content);
+  } catch (err) {
+    restoreTaskState(deps.taskEngine, task);
+    deps.logger.warn("failed to start local follow-up execution", {
+      taskId: task.id,
+      ...metadata,
+      error: err instanceof Error ? err.message : String(err)
+    });
+    throw err;
+  }
+}
+// ../../packages/api/src/tasks/task-message-queue.ts
+var registeredDrainers = /* @__PURE__ */ new WeakSet();
+var drainingTaskIds = /* @__PURE__ */ new Set();
+var QUEUE_DRAIN_STATUSES = /* @__PURE__ */ new Set(["completed", "cancelled"]);
+function restoreQueuedMessage(taskEngine, taskId, message) {
+  const current = taskEngine.getTask(taskId);
+  if (!current) return;
+  taskEngine.updateTask(taskId, {
+    queuedMessages: [message, ...current.queuedMessages ?? []]
+  });
+}
+async function sendTaskFollowUpMessage(deps, task, content, metadata) {
+  if (!supportsFollowUpAgent(task.agent)) {
+    throw new MeshyError("VALIDATION_ERROR", `Agent ${task.agent} does not support chat messages`, 400);
+  }
+  if (task.assignedTo && task.assignedTo !== deps.nodeRegistry.getSelf()?.id) {
+    const node = deps.nodeRegistry.getNode(task.assignedTo);
+    const log2 = deps.logger.child("tasks/message");
+    if (!node || node.status === "offline") {
+      log2.warn("assigned worker unavailable for follow-up", {
+        taskId: task.id,
+        assignedTo: task.assignedTo,
+        nodeFound: Boolean(node),
+        nodeStatus: node?.status,
+        ...metadata
+      });
+      throw new MeshyError(
+        "NODE_OFFLINE",
+        `Task ${task.id} is unavailable because ${task.assignedNodeName ?? task.assignedTo} is no longer reachable`,
+        409
+      );
+    }
+    deps.taskEngine.updateTask(task.id, { status: "running" });
+    log2.info("proxying follow-up message to worker", {
+      taskId: task.id,
+      assignedTo: task.assignedTo,
+      ...metadata
+    });
+    try {
+      const client = new NodeMessageClient({ heartbeat: deps.heartbeat, logger: deps.logger });
+      const delivery = await client.send(node, createNodeMessage("task.message", { taskId: task.id, content }));
+      return delivery.queued ? { queued: true } : {};
+    } catch (err) {
+      restoreTaskState(deps.taskEngine, task);
+      const message = err instanceof Error ? err.message : String(err);
+      log2.warn("failed to proxy follow-up message to worker", {
+        taskId: task.id,
+        assignedTo: task.assignedTo,
+        error: message,
+        ...metadata
+      });
+      throw err instanceof MeshyError ? err : new MeshyError("NODE_OFFLINE", `Failed to proxy follow-up message to worker: ${message}`, 502);
+    }
+  }
+  startLocalTaskFollowUp({
+    taskEngine: deps.taskEngine,
+    engineRegistry: deps.engineRegistry,
+    logger: deps.logger.child("tasks/message")
+  }, task, content, task.assignedTo, metadata);
+  return {};
+}
+function queueRunningTaskMessage(deps, task, content) {
+  if (!supportsFollowUpAgent(task.agent)) {
+    throw new MeshyError("VALIDATION_ERROR", `Agent ${task.agent} does not support chat messages`, 400);
+  }
+  const queued = deps.taskEngine.enqueueTaskMessage(task.id, content);
+  deps.logger.child("tasks/message").info("queued follow-up message for running task", {
+    taskId: task.id,
+    queuedCount: queued.queuedMessages?.length ?? 0
+  });
+  return queued;
+}
+function cancelQueuedTaskMessage(deps, taskId, messageId) {
+  const task = deps.taskEngine.removeQueuedTaskMessage(taskId, messageId);
+  if (!task) {
+    throw new MeshyError("TASK_NOT_FOUND", `Queued message ${messageId} not found for task ${taskId}`, 404);
+  }
+  deps.logger.child("tasks/message").info("cancelled queued follow-up message", {
+    taskId,
+    queuedMessageId: messageId,
+    queuedCount: task.queuedMessages?.length ?? 0
+  });
+  return task;
+}
+function registerTaskMessageQueueDrainer(deps) {
+  if (registeredDrainers.has(deps.eventBus)) return;
+  registeredDrainers.add(deps.eventBus);
+  deps.eventBus.on("task.status", (data) => {
+    if (!QUEUE_DRAIN_STATUSES.has(data.status)) return;
+    void drainNextQueuedTaskMessage(deps, data.taskId);
+  });
+}
+async function drainNextQueuedTaskMessage(deps, taskId) {
+  if (drainingTaskIds.has(taskId)) return false;
+  const task = deps.taskEngine.getTask(taskId);
+  if (!task || !QUEUE_DRAIN_STATUSES.has(task.status) || !task.queuedMessages?.length) {
+    return false;
+  }
+  const dequeued = deps.taskEngine.dequeueTaskMessage(taskId);
+  if (!dequeued) return false;
+  drainingTaskIds.add(taskId);
+  try {
+    await sendTaskFollowUpMessage(deps, dequeued.task, dequeued.message.content, {
+      queuedMessageId: dequeued.message.id
+    });
+    deps.logger.child("tasks/message").info("started queued follow-up message", {
+      taskId,
+      queuedMessageId: dequeued.message.id,
+      remainingQueuedCount: dequeued.task.queuedMessages?.length ?? 0
+    });
+    return true;
+  } catch (err) {
+    restoreQueuedMessage(deps.taskEngine, taskId, dequeued.message);
+    deps.logger.child("tasks/message").warn("failed to start queued follow-up message", {
+      taskId,
+      queuedMessageId: dequeued.message.id,
+      error: err instanceof Error ? err.message : String(err)
+    });
+    return false;
+  } finally {
+    drainingTaskIds.delete(taskId);
+  }
+}
 // ../../packages/api/src/routes/task-output.ts
 var import_express8 = __toESM(require_express2(), 1);
@@ -64820,63 +65017,39 @@ function createTaskRoutes() {
   router.get("/:id/logs", asyncHandler7(async (req, res) => {
     await sendTaskLogsResponse(req, res, req.params.id);
   }));
+  router.delete("/:id/queued-messages/:messageId", asyncHandler7(async (req, res) => {
+    const { taskEngine, logger: rootLogger } = req.app.locals.deps;
+    const task = cancelQueuedTaskMessage(
+      { taskEngine, logger: rootLogger },
+      req.params.id,
+      req.params.messageId
+    );
+    res.json({ ok: true, queuedMessages: task.queuedMessages ?? [] });
+  }));
   router.post("/:id/message", asyncHandler7(async (req, res) => {
     const { taskEngine, engineRegistry, nodeRegistry, heartbeat, logger: rootLogger } = req.app.locals.deps;
-    const log2 = rootLogger.child("tasks/message");
     const body = SendMessageBody.parse(req.body);
     const taskId = req.params.id;
     const task = taskEngine.getTask(taskId);
     if (!task) {
       throw new MeshyError("TASK_NOT_FOUND", `Task ${taskId} not found`, 404);
     }
-    if (!supportsFollowUpAgent(task.agent)) {
-      throw new MeshyError("VALIDATION_ERROR", `Agent ${task.agent} does not support chat messages`, 400);
-    }
     if (!["running", "completed", "cancelled"].includes(task.status)) {
       throw new MeshyError("VALIDATION_ERROR", `Cannot send message to task in ${task.status} status`, 400);
     }
-    if (task.assignedTo && task.assignedTo !== nodeRegistry.getSelf()?.id) {
-      const node = nodeRegistry.getNode(task.assignedTo);
-      if (!node || node.status === "offline") {
-        log2.warn("assigned worker unavailable for follow-up", {
-          taskId: task.id,
-          assignedTo: task.assignedTo,
-          nodeFound: Boolean(node),
-          nodeStatus: node?.status
-        });
-        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" });
-      log2.info("proxying follow-up message to worker", {
-        taskId: task.id,
-        assignedTo: task.assignedTo
-      });
-      try {
-        const client = new NodeMessageClient({ heartbeat, logger: rootLogger });
-        const delivery = await client.send(node, createNodeMessage("task.message", { taskId: task.id, content: body.content }));
-        res.json(delivery.queued ? { ok: true, queued: true } : { ok: true });
-        return;
-      } catch (err) {
-        restoreTaskState(taskEngine, task);
-        const message = err instanceof Error ? err.message : String(err);
-        log2.warn("failed to proxy follow-up message to worker", {
-          taskId: task.id,
-          assignedTo: task.assignedTo,
-          error: message
-        });
-        throw err instanceof MeshyError ? err : new MeshyError("NODE_OFFLINE", `Failed to proxy follow-up message to worker: ${message}`, 502);
-      }
+    if (task.status === "running") {
+      const queued = queueRunningTaskMessage({ taskEngine, logger: rootLogger }, task, body.content);
+      res.json({ ok: true, queued: true, queuedMessages: queued.queuedMessages ?? [] });
+      return;
     }
-    startLocalTaskFollowUp({
+    const result = await sendTaskFollowUpMessage({
       taskEngine,
       engineRegistry,
-      logger: log2
-    }, task, body.content, task.assignedTo);
-    res.json({ ok: true });
+      nodeRegistry,
+      heartbeat,
+      logger: rootLogger
+    }, task, body.content);
+    res.json(result.queued ? { ok: true, queued: true } : { ok: true });
   }));
   router.use(createTaskOutputRoutes());
   return router;
@@ -65592,6 +65765,7 @@ function resolveStaticDir(baseDir) {
 function createServer2(deps) {
   const app = (0, import_express15.default)();
   app.locals.deps = deps;
+  registerTaskMessageQueueDrainer(deps);
   if (typeof deps.heartbeat.setNodeMessageHandler === "function") {
     deps.heartbeat.setNodeMessageHandler((message) => handleNodeMessage(deps, message));
   }
@@ -65730,11 +65904,25 @@ function createDevBoxStatusPoller(deps, options = {}) {
     const checkedAt = node.devbox?.checkedAt;
     return typeof checkedAt !== "number" || now - checkedAt >= staleAfterMs;
   }
+  function hasActiveStartOperation(nodeId) {
+    const operationService = getNodeOperationService(deps);
+    return operationService.list({ kind: "devbox.start", status: "queued" }).some((operation) => operation.nodeId === nodeId) || operationService.list({ kind: "devbox.start", status: "running" }).some((operation) => operation.nodeId === nodeId);
+  }
+  function maybeStartAlwaysOnlineDevBox(node, refreshedStatus) {
+    if (node.status !== "offline") return;
+    if (node.devbox?.alwaysOnline !== true) return;
+    if (!isAlwaysOnlineStartableDevBoxStatus(refreshedStatus)) return;
+    if (hasActiveStartOperation(node.id)) return;
+    const operationService = getNodeOperationService(deps);
+    const operation = operationService.create("devbox.start", node.id, { previousStatus: refreshedStatus ?? "" });
+    operationService.runLocal(operation.id);
+  }
   async function refreshNode(node) {
     if (inFlight.has(node.id)) return;
     inFlight.add(node.id);
     try {
-      await refreshNodeDevBoxStatus(deps, node);
+      const refreshed = await refreshNodeDevBoxStatus(deps, node);
+      maybeStartAlwaysOnlineDevBox(node, refreshed.lastStatus);
     } catch (err) {
       logger27.debug(`refresh failed for ${node.name}: ${err instanceof Error ? err.message : String(err)}`);
     } finally {

package/package.json CHANGED Viewed

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

package/runtime-metadata.json CHANGED Viewed

@@ -1,14 +1,14 @@
 {
   "packageName": "meshy-node",
-  "packageVersion": "0.5.6",
+  "packageVersion": "0.5.7",
   "packages": {
     "workspace": {
       "name": "meshy",
-      "version": "0.5.6"
+      "version": "0.5.7"
     },
     "node": {
       "name": "meshy-node",
-      "version": "0.5.6"
+      "version": "0.5.7"
     },
     "core": {
       "name": "@meshy/core",
@@ -25,7 +25,7 @@
   },
   "repository": {
     "url": "https://github.com/ai-microsoft/meshy",
-    "branch": "FixDevBoxNaming",
-    "commit": "e313b30"
+    "branch": "DevBoxAlwaysOnline",
+    "commit": "9635e1a"
   }
 }