meshy-node 0.3.8 → 0.3.9

package/main.cjs

@@ -33297,6 +33297,7 @@ function createNodeMessage(kind, payload, options = {}) {
 }
 
 // ../../packages/core/src/messaging/node-message-client.ts
+var RETRYABLE_NODE_MESSAGE_STATUSES = /* @__PURE__ */ new Set([502, 503, 504]);
 var NodeMessageClient = class {
   constructor(options = {}) {
     this.options = options;
@@ -33335,6 +33336,16 @@ var NodeMessageClient = class {
       throw error;
     }
     if (!response.ok) {
+      if (RETRYABLE_NODE_MESSAGE_STATUSES.has(response.status) && this.options.heartbeat?.enqueueNodeMessage) {
+        this.log?.warn("direct node message delivery returned retryable status; queued for keepalive", {
+          nodeId: node.id,
+          messageId: message.id,
+          kind: message.kind,
+          statusCode: response.status
+        });
+        this.options.heartbeat.enqueueNodeMessage(node.id, message);
+        return { queued: true };
+      }
       throw new Error(await formatHttpError(response));
     }
     return { queued: false };
@@ -43063,6 +43074,7 @@ var NativeSessionSummarySchema = external_exports.object({
   summary: external_exports.string(),
   updatedAt: external_exports.string().nullable()
 });
+var NodeOperationStatusSchema = external_exports.enum(["queued", "running", "succeeded", "failed"]);
 var NodeListQuery = external_exports.object({
   status: external_exports.enum(["online", "busy", "offline"]).optional(),
   capability: external_exports.string().optional()
@@ -43141,7 +43153,7 @@ var NodeNativeSessionsResponse = external_exports.object({
   agent: external_exports.enum(["codex", "claudecode"]),
   sessions: external_exports.array(NativeSessionSummarySchema)
 });
-var NodeTerminalExecuteResponse = external_exports.object({
+var NodeTerminalExecuteResult = external_exports.object({
   nodeId: external_exports.string(),
   cwd: external_exports.string(),
   command: external_exports.string(),
@@ -43153,6 +43165,20 @@ var NodeTerminalExecuteResponse = external_exports.object({
   stdoutTruncated: external_exports.boolean(),
   stderrTruncated: external_exports.boolean()
 });
+var NodeTerminalExecuteResponse = external_exports.object({
+  id: external_exports.string(),
+  kind: external_exports.literal("terminal.execute"),
+  nodeId: external_exports.string(),
+  requestedByNodeId: external_exports.string().optional(),
+  status: NodeOperationStatusSchema,
+  payload: NodeTerminalExecuteBody,
+  result: NodeTerminalExecuteResult.optional(),
+  error: external_exports.string().optional(),
+  createdAt: external_exports.number(),
+  updatedAt: external_exports.number(),
+  startedAt: external_exports.number().optional(),
+  completedAt: external_exports.number().optional()
+});
 var UpdateNodeBody = external_exports.object({
   name: external_exports.string().min(1).optional(),
   capabilities: external_exports.array(external_exports.string()).optional()
@@ -44477,8 +44503,8 @@ function computeParentPath(rootPath, currentPath, useAbsolute) {
 }
 
 // ../../packages/api/src/node/node-operation-service.ts
-var fs15 = __toESM(require("fs"), 1);
-var path17 = __toESM(require("path"), 1);
+var fs16 = __toESM(require("fs"), 1);
+var path18 = __toESM(require("path"), 1);
 var import_node_crypto7 = require("crypto");
 
 // ../../packages/api/src/node/agent-upgrade-service.ts
@@ -44764,6 +44790,95 @@ function upgradeRuntimeAgentForDeps(deps, agent) {
   return result;
 }
 
+// ../../packages/api/src/node/node-terminal-service.ts
+var import_node_child_process10 = require("child_process");
+var fs15 = __toESM(require("fs"), 1);
+var path17 = __toESM(require("path"), 1);
+var DEFAULT_TIMEOUT_MS = 3e4;
+var DEFAULT_OUTPUT_LIMIT_BYTES = 64 * 1024;
+function isAbsolutePath2(value) {
+  return path17.isAbsolute(value) || /^[A-Za-z]:[\/]/.test(value);
+}
+function resolveCommandCwd(nodeId, rootPath, cwd) {
+  if (!rootPath) {
+    throw new MeshyError("VALIDATION_ERROR", `Node ${nodeId} does not expose a working directory`, 400);
+  }
+  const requestedCwd = cwd?.trim() || ".";
+  const resolved = isAbsolutePath2(requestedCwd) ? path17.resolve(requestedCwd) : path17.resolve(rootPath, requestedCwd);
+  if (!fs15.existsSync(resolved) || !fs15.statSync(resolved).isDirectory()) {
+    throw new MeshyError("VALIDATION_ERROR", `Working directory does not exist: ${resolved}`, 400);
+  }
+  return resolved;
+}
+function captureLimited(chunks, chunk, currentBytes, limitBytes) {
+  if (currentBytes >= limitBytes) {
+    return currentBytes + chunk.length;
+  }
+  const remaining = limitBytes - currentBytes;
+  chunks.push(chunk.length <= remaining ? chunk : chunk.subarray(0, remaining));
+  return currentBytes + chunk.length;
+}
+function toCapturedOutput(chunks, observedBytes, limitBytes) {
+  return {
+    text: Buffer.concat(chunks).toString("utf8"),
+    truncated: observedBytes > limitBytes
+  };
+}
+function executeLocalNodeTerminalCommand(nodeId, rootPath, command, options = {}) {
+  const normalizedCommand = command.trim();
+  if (!normalizedCommand) {
+    throw new MeshyError("VALIDATION_ERROR", "Command must not be empty", 400);
+  }
+  const cwd = resolveCommandCwd(nodeId, rootPath, options.cwd);
+  const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  const outputLimitBytes = options.outputLimitBytes ?? DEFAULT_OUTPUT_LIMIT_BYTES;
+  const startedAt = Date.now();
+  const stdoutChunks = [];
+  const stderrChunks = [];
+  let stdoutBytes = 0;
+  let stderrBytes = 0;
+  let timedOut = false;
+  return new Promise((resolve15, reject) => {
+    const child = (0, import_node_child_process10.spawn)(normalizedCommand, {
+      cwd,
+      shell: true,
+      windowsHide: true,
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    const timeout = setTimeout(() => {
+      timedOut = true;
+      child.kill("SIGTERM");
+    }, timeoutMs);
+    child.stdout?.on("data", (chunk) => {
+      stdoutBytes = captureLimited(stdoutChunks, chunk, stdoutBytes, outputLimitBytes);
+    });
+    child.stderr?.on("data", (chunk) => {
+      stderrBytes = captureLimited(stderrChunks, chunk, stderrBytes, outputLimitBytes);
+    });
+    child.on("error", (err) => {
+      clearTimeout(timeout);
+      reject(new MeshyError("VALIDATION_ERROR", err.message, 400));
+    });
+    child.on("close", (code) => {
+      clearTimeout(timeout);
+      const stdout = toCapturedOutput(stdoutChunks, stdoutBytes, outputLimitBytes);
+      const stderr = toCapturedOutput(stderrChunks, stderrBytes, outputLimitBytes);
+      resolve15({
+        nodeId,
+        cwd,
+        command: normalizedCommand,
+        exitCode: code,
+        stdout: stdout.text,
+        stderr: stderr.text,
+        durationMs: Date.now() - startedAt,
+        timedOut,
+        stdoutTruncated: stdout.truncated,
+        stderrTruncated: stderr.truncated
+      });
+    });
+  });
+}
+
 // ../../packages/api/src/node/node-operation-service.ts
 var NodeOperationFailure = class extends Error {
   constructor(message, result) {
@@ -44827,8 +44942,8 @@ var FileNodeOperationStore = class {
   load() {
     if (this.loaded) return;
     this.loaded = true;
-    if (!fs15.existsSync(this.filePath)) return;
-    const raw = JSON.parse(fs15.readFileSync(this.filePath, "utf-8"));
+    if (!fs16.existsSync(this.filePath)) return;
+    const raw = JSON.parse(fs16.readFileSync(this.filePath, "utf-8"));
     const entries = Array.isArray(raw) ? raw : Object.values(raw);
     for (const entry of entries) {
       if (isNodeOperation(entry)) {
@@ -44837,14 +44952,14 @@ var FileNodeOperationStore = class {
     }
   }
   persist() {
-    fs15.mkdirSync(this.storagePath, { recursive: true });
+    fs16.mkdirSync(this.storagePath, { recursive: true });
     const body = JSON.stringify(Object.fromEntries(this.operations), null, 2);
     const tmpPath = `${this.filePath}.tmp`;
-    fs15.writeFileSync(tmpPath, body, "utf-8");
-    fs15.renameSync(tmpPath, this.filePath);
+    fs16.writeFileSync(tmpPath, body, "utf-8");
+    fs16.renameSync(tmpPath, this.filePath);
   }
   get filePath() {
-    return path17.join(this.storagePath, "node-operations.json");
+    return path18.join(this.storagePath, "node-operations.json");
   }
 };
 var NodeOperationService = class {
@@ -44852,6 +44967,7 @@ var NodeOperationService = class {
     this.deps = deps;
     this.store = store;
     this.registerHandler("agent.upgrade", runAgentUpgradeOperation);
+    this.registerHandler("terminal.execute", runTerminalExecuteOperation);
     this.registerHandler("workdir.branch-create", runWorkDirBranchCreateOperation);
   }
   handlers = /* @__PURE__ */ new Map();
@@ -44997,6 +45113,15 @@ function runAgentUpgradeOperation(operation, deps) {
   }
   return result;
 }
+async function runTerminalExecuteOperation(operation, deps) {
+  const self2 = deps.nodeRegistry.getSelf();
+  return executeLocalNodeTerminalCommand(
+    self2.id,
+    self2.workDir ?? deps.workDir,
+    readPayloadString(operation, "command"),
+    { cwd: readPayloadString(operation, "cwd") || void 0 }
+  );
+}
 function runWorkDirBranchCreateOperation(operation, deps) {
   const self2 = deps.nodeRegistry.getSelf();
   return createLocalNodeWorkDirBranch(
@@ -45154,7 +45279,7 @@ async function sendNodeWorkDirBranchCreateOperation(req, res, nodeId) {
 }
 
 // ../../packages/api/src/tasks/task-route-utils.ts
-var fs16 = __toESM(require("fs"), 1);
+var fs17 = __toESM(require("fs"), 1);
 var import_node_stream2 = require("stream");
 var import_promises5 = require("stream/promises");
 
@@ -45209,10 +45334,10 @@ function readLocalTaskLogs(engineRegistry, taskId, after, agent) {
     throw new MeshyError("VALIDATION_ERROR", `Engine not registered for agent: ${agent}`, 400);
   }
   const logPath = engine.getLogPath(taskId);
-  if (!fs16.existsSync(logPath)) {
+  if (!fs17.existsSync(logPath)) {
     return { logs: [], total: 0 };
   }
-  const content = fs16.readFileSync(logPath, "utf-8");
+  const content = fs17.readFileSync(logPath, "utf-8");
   const allLines = content.trim().split("\n").filter(Boolean);
   const logs = [];
   for (let i = after; i < allLines.length; i++) {
@@ -45442,95 +45567,6 @@ async function maybeProxyReadToLeader(req, res, options = {}) {
   }
 }
 
-// ../../packages/api/src/node/node-terminal-service.ts
-var import_node_child_process10 = require("child_process");
-var fs17 = __toESM(require("fs"), 1);
-var path18 = __toESM(require("path"), 1);
-var DEFAULT_TIMEOUT_MS = 3e4;
-var DEFAULT_OUTPUT_LIMIT_BYTES = 64 * 1024;
-function isAbsolutePath2(value) {
-  return path18.isAbsolute(value) || /^[A-Za-z]:[\/]/.test(value);
-}
-function resolveCommandCwd(nodeId, rootPath, cwd) {
-  if (!rootPath) {
-    throw new MeshyError("VALIDATION_ERROR", `Node ${nodeId} does not expose a working directory`, 400);
-  }
-  const requestedCwd = cwd?.trim() || ".";
-  const resolved = isAbsolutePath2(requestedCwd) ? path18.resolve(requestedCwd) : path18.resolve(rootPath, requestedCwd);
-  if (!fs17.existsSync(resolved) || !fs17.statSync(resolved).isDirectory()) {
-    throw new MeshyError("VALIDATION_ERROR", `Working directory does not exist: ${resolved}`, 400);
-  }
-  return resolved;
-}
-function captureLimited(chunks, chunk, currentBytes, limitBytes) {
-  if (currentBytes >= limitBytes) {
-    return currentBytes + chunk.length;
-  }
-  const remaining = limitBytes - currentBytes;
-  chunks.push(chunk.length <= remaining ? chunk : chunk.subarray(0, remaining));
-  return currentBytes + chunk.length;
-}
-function toCapturedOutput(chunks, observedBytes, limitBytes) {
-  return {
-    text: Buffer.concat(chunks).toString("utf8"),
-    truncated: observedBytes > limitBytes
-  };
-}
-function executeLocalNodeTerminalCommand(nodeId, rootPath, command, options = {}) {
-  const normalizedCommand = command.trim();
-  if (!normalizedCommand) {
-    throw new MeshyError("VALIDATION_ERROR", "Command must not be empty", 400);
-  }
-  const cwd = resolveCommandCwd(nodeId, rootPath, options.cwd);
-  const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
-  const outputLimitBytes = options.outputLimitBytes ?? DEFAULT_OUTPUT_LIMIT_BYTES;
-  const startedAt = Date.now();
-  const stdoutChunks = [];
-  const stderrChunks = [];
-  let stdoutBytes = 0;
-  let stderrBytes = 0;
-  let timedOut = false;
-  return new Promise((resolve15, reject) => {
-    const child = (0, import_node_child_process10.spawn)(normalizedCommand, {
-      cwd,
-      shell: true,
-      windowsHide: true,
-      stdio: ["ignore", "pipe", "pipe"]
-    });
-    const timeout = setTimeout(() => {
-      timedOut = true;
-      child.kill("SIGTERM");
-    }, timeoutMs);
-    child.stdout?.on("data", (chunk) => {
-      stdoutBytes = captureLimited(stdoutChunks, chunk, stdoutBytes, outputLimitBytes);
-    });
-    child.stderr?.on("data", (chunk) => {
-      stderrBytes = captureLimited(stderrChunks, chunk, stderrBytes, outputLimitBytes);
-    });
-    child.on("error", (err) => {
-      clearTimeout(timeout);
-      reject(new MeshyError("VALIDATION_ERROR", err.message, 400));
-    });
-    child.on("close", (code) => {
-      clearTimeout(timeout);
-      const stdout = toCapturedOutput(stdoutChunks, stdoutBytes, outputLimitBytes);
-      const stderr = toCapturedOutput(stderrChunks, stderrBytes, outputLimitBytes);
-      resolve15({
-        nodeId,
-        cwd,
-        command: normalizedCommand,
-        exitCode: code,
-        stdout: stdout.text,
-        stderr: stderr.text,
-        durationMs: Date.now() - startedAt,
-        timedOut,
-        stdoutTruncated: stdout.truncated,
-        stderrTruncated: stderr.truncated
-      });
-    });
-  });
-}
-
 // ../../packages/api/src/node/node-native-session-service.ts
 function getLocalNodeNativeSessions(nodeId, agent, limit) {
   return {
@@ -46954,142 +46990,35 @@ async function sendNodeAgentUpgrade(req, res, nodeId, agentParam) {
 }
 
 // ../../packages/api/src/routes/node-terminal.ts
-var NODE_TERMINAL_PROXY_TIMEOUT_MS = 35e3;
-function describeProxyError2(error) {
-  if (error instanceof Error) {
-    const errorCategory = error.name === "AbortError" || /aborted/i.test(error.message) ? "abort" : /timeout/i.test(error.message) ? "timeout" : "network";
-    return {
-      errorName: error.name,
-      errorMessage: error.message,
-      errorCategory
-    };
-  }
-  return {
-    errorName: "UnknownError",
-    errorMessage: String(error),
-    errorCategory: "unknown"
-  };
-}
-function createNodeTerminalProxyTrace(log2, nodeId, proxyPath) {
-  return {
-    onAttempt: ({ attempt, endpoint, timeoutMs, totalEndpoints }) => {
-      log2.debug("node terminal proxy attempt", {
-        nodeId,
-        proxyPath,
-        endpoint,
-        attempt,
-        totalEndpoints,
-        timeoutMs
-      });
-    },
-    onResponse: ({ attempt, endpoint, response, timeoutMs, totalEndpoints }) => {
-      log2.info("node terminal proxy response", {
-        nodeId,
-        proxyPath,
-        endpoint,
-        attempt,
-        totalEndpoints,
-        timeoutMs,
-        ok: response.ok,
-        statusCode: response.status
-      });
-    },
-    onError: ({ attempt, endpoint, error, timeoutMs, totalEndpoints }) => {
-      log2.warn("node terminal proxy attempt failed", {
-        nodeId,
-        proxyPath,
-        endpoint,
-        attempt,
-        totalEndpoints,
-        timeoutMs,
-        ...describeProxyError2(error)
-      });
-    }
-  };
-}
-async function maybeHandleRemoteNodeTerminalExecuteRequest(req, res, nodeId) {
+async function sendNodeTerminalExecuteOperation(req, res, nodeId) {
   const body = NodeTerminalExecuteBody.parse(req.body);
-  const { nodeRegistry, heartbeat, logger: rootLogger } = req.app.locals.deps;
+  const deps = req.app.locals.deps;
+  const { nodeRegistry } = deps;
   const selfId = nodeRegistry.getSelf().id;
-  if (nodeId === selfId) {
-    return false;
-  }
-  const node = nodeRegistry.getNode(nodeId);
-  if (!node) {
-    throw new MeshyError("NODE_NOT_FOUND", `Node ${nodeId} not found`, 404);
-  }
-  const log2 = rootLogger.child("nodes/terminal");
-  const proxyPath = req.originalUrl ?? `/api/nodes/${nodeId}/terminal/execute`;
-  const fallbackRequest = createNodeMessage("node.terminal.execute", {
+  const node = nodeId === selfId ? nodeRegistry.getSelf() : nodeRegistry.getNode(nodeId);
+  if (!node) throw new MeshyError("NODE_NOT_FOUND", `Node ${nodeId} not found`, 404);
+  const operations = getNodeOperationService(deps);
+  const operation = operations.create("terminal.execute", nodeId, {
     command: body.command,
     cwd: body.cwd
-  }, { expectsResponse: true });
-  const canPushToNode = heartbeat?.canPushToNode?.(nodeId) ?? true;
-  if (!canPushToNode && canRequestNodeMessage(heartbeat)) {
-    log2.warn("node terminal request falling back to keepalive control", { nodeId, proxyPath });
-    const controlResponse = await requestFallbackNodeMessage(heartbeat, nodeId, fallbackRequest);
-    sendWorkerControlResponse(res, controlResponse);
-    return true;
-  }
-  try {
-    const { endpoint, response } = await fetchNodeWithFallback(
-      node,
-      proxyPath,
-      {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify(body)
-      },
-      NODE_TERMINAL_PROXY_TIMEOUT_MS,
-      createNodeTerminalProxyTrace(log2, nodeId, proxyPath),
-      { preferPublicEndpoint: true }
-    );
-    log2.debug("proxying node terminal request", { nodeId, endpoint, proxyPath });
-    await sendProxyResponse(res, response);
-    return true;
-  } catch (err) {
-    const errorDetails = describeProxyError2(err);
-    log2.warn("node terminal proxy error", {
-      nodeId,
-      proxyPath,
-      timeoutMs: NODE_TERMINAL_PROXY_TIMEOUT_MS,
-      ...errorDetails
-    });
-    if (canRequestNodeMessage(heartbeat)) {
-      log2.warn("node terminal proxy failed, falling back to keepalive control", {
-        nodeId,
-        proxyPath,
-        timeoutMs: NODE_TERMINAL_PROXY_TIMEOUT_MS,
-        ...errorDetails
-      });
-      const controlResponse = await requestFallbackNodeMessage(heartbeat, nodeId, fallbackRequest);
-      sendWorkerControlResponse(res, controlResponse);
-      return true;
+  });
+  if (nodeId === selfId) {
+    operations.runLocal(operation.id);
+  } else {
+    try {
+      await dispatchNodeOperation(deps, operation, node);
+    } catch (err) {
+      operations.markFailed(operation.id, err instanceof Error ? err.message : String(err));
     }
-    throw new MeshyError("NODE_OFFLINE", `Cannot reach node ${nodeId} to execute a terminal command`, 502);
-  }
-}
-async function sendLocalNodeTerminalExecute(req, res, nodeId) {
-  const body = NodeTerminalExecuteBody.parse(req.body);
-  const { nodeRegistry, workDir } = req.app.locals.deps;
-  const self2 = nodeRegistry.getSelf();
-  if (nodeId !== self2.id) {
-    throw new MeshyError("NODE_NOT_FOUND", `Node ${nodeId} not found`, 404);
   }
-  const result = await executeLocalNodeTerminalCommand(
-    self2.id,
-    self2.workDir ?? workDir,
-    body.command,
-    { cwd: body.cwd }
-  );
-  res.json(result);
+  res.status(202).json(operation);
 }
 
 // ../../packages/api/src/routes/nodes.ts
 var NODE_WORKDIR_PROXY_TIMEOUT_MS = 1e4;
 var NODE_WORKDIR_BRANCH_PROXY_TIMEOUT_MS = 25e3;
 var NODE_NATIVE_SESSIONS_PROXY_TIMEOUT_MS = 1e4;
-function describeProxyError3(error) {
+function describeProxyError2(error) {
   if (error instanceof Error) {
     const errorCategory = error.name === "AbortError" || /aborted/i.test(error.message) ? "abort" : /timeout/i.test(error.message) ? "timeout" : "network";
     return {
@@ -47136,7 +47065,7 @@ function createNodeWorkdirProxyTrace(log2, nodeId, proxyPath) {
         attempt,
         totalEndpoints,
         timeoutMs,
-        ...describeProxyError3(error)
+        ...describeProxyError2(error)
       });
     }
   };
@@ -47191,7 +47120,7 @@ async function maybeHandleRemoteNodeWorkDirRequest(req, res, nodeId) {
     await sendProxyResponse(res, response);
     return true;
   } catch (err) {
-    const errorDetails = describeProxyError3(err);
+    const errorDetails = describeProxyError2(err);
     log2.warn("node workdir proxy error", {
       nodeId,
       proxyPath,
@@ -47258,7 +47187,7 @@ async function maybeHandleRemoteNodeWorkDirBranchInfoRequest(req, res, nodeId) {
     await sendProxyResponse(res, response);
     return true;
   } catch (err) {
-    const errorDetails = describeProxyError3(err);
+    const errorDetails = describeProxyError2(err);
     log2.warn("node workdir branch proxy error", {
       nodeId,
       proxyPath,
@@ -47323,7 +47252,7 @@ async function maybeHandleRemoteNodeNativeSessionsRequest(req, res, nodeId) {
     await sendProxyResponse(res, response);
     return true;
   } catch (err) {
-    const errorDetails = describeProxyError3(err);
+    const errorDetails = describeProxyError2(err);
     log2.warn("node native sessions proxy error", {
       nodeId,
       proxyPath,
@@ -47412,11 +47341,7 @@ function createNodeRoutes() {
   }));
   router.post("/:id/terminal/execute", asyncHandler3(async (req, res) => {
     const nodeId = req.params.id;
-    const handled = await maybeHandleRemoteNodeTerminalExecuteRequest(req, res, nodeId);
-    if (handled) {
-      return;
-    }
-    await sendLocalNodeTerminalExecute(req, res, nodeId);
+    await sendNodeTerminalExecuteOperation(req, res, nodeId);
   }));
   router.post("/:id/workdir/branch", asyncHandler3(async (req, res) => {
     const nodeId = req.params.id;
@@ -47837,7 +47762,7 @@ function getTaskLogsProxyRequestMetadata(req) {
   const sourceNodeId = req.get(TASK_LOG_PROXY_SOURCE_HEADER) ?? void 0;
   return { isProxy: purpose === TASK_LOG_PROXY_PURPOSE, sourceNodeId, task: decodeTaskSnapshot(req.get(TASK_LOG_PROXY_TASK_HEADER)) };
 }
-function describeProxyError4(error) {
+function describeProxyError3(error) {
   if (error instanceof Error) {
     const errorCategory = error.name === "AbortError" || /aborted/i.test(error.message) ? "abort" : /timeout/i.test(error.message) ? "timeout" : "network";
     return {
@@ -47879,7 +47804,7 @@ function createTaskLogsProxyTrace(log2, taskId, nodeId, proxyPath) {
         attempt,
         totalEndpoints,
         timeoutMs,
-        ...describeProxyError4(error)
+        ...describeProxyError3(error)
       });
     }
   };
@@ -47957,7 +47882,7 @@ async function sendTaskLogsResponse(req, res, taskId) {
         log2.warn("failed to seed task snapshot before task logs proxy", {
           taskId,
           assignedTo,
-          ...describeProxyError4(err)
+          ...describeProxyError3(err)
         });
         return [];
       });
@@ -47990,7 +47915,7 @@ async function sendTaskLogsResponse(req, res, taskId) {
           taskId,
           assignedTo,
           timeoutMs: TASK_LOG_PROXY_TIMEOUT_MS,
-          ...describeProxyError4(err)
+          ...describeProxyError3(err)
         });
         const fallback = await requestTaskLogsOverKeepalive(heartbeat, assignedTo, task, after);
         if (fallback) {
@@ -48067,7 +47992,7 @@ function resolveRequestOrigin(req) {
 
 // ../../packages/api/src/routes/task-output.ts
 var TASK_OUTPUT_PROXY_TIMEOUT_MS = 1e4;
-function describeProxyError5(error) {
+function describeProxyError4(error) {
   if (error instanceof Error) {
     const errorCategory = error.name === "AbortError" || /aborted/i.test(error.message) ? "abort" : /timeout/i.test(error.message) ? "timeout" : "network";
     return {
@@ -48120,7 +48045,7 @@ function createTaskOutputProxyTrace(log2, taskId, assignedTo, kind, proxyPath) {
         attempt,
         totalEndpoints,
         timeoutMs,
-        ...describeProxyError5(error)
+        ...describeProxyError4(error)
       });
     }
   };
@@ -48238,7 +48163,7 @@ async function maybeHandleRemoteTaskOutputRequest(req, res, taskId, subPath, ini
         assignedTo: assignedNodeId,
         kind: hydratedFallbackRequest.kind,
         timeoutMs: TASK_OUTPUT_PROXY_TIMEOUT_MS,
-        ...describeProxyError5(err)
+        ...describeProxyError4(err)
       });
       const controlResponse = await requestFallbackNodeMessage(heartbeat, assignedNodeId, hydratedFallbackRequest);
       if (hydratedFallbackRequest.kind === "task.preview.create" && controlResponse.bodyEncoding === "json" && isPreviewSessionPayload(controlResponse.body)) {
@@ -48255,7 +48180,7 @@ async function maybeHandleRemoteTaskOutputRequest(req, res, taskId, subPath, ini
       assignedTo: assignedNodeId,
       kind: messageKind,
       timeoutMs: TASK_OUTPUT_PROXY_TIMEOUT_MS,
-      ...describeProxyError5(err)
+      ...describeProxyError4(err)
     });
     throw new MeshyError("NODE_OFFLINE", "Cannot reach worker for task output", 502);
   }

package/package.json

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

package/runtime-metadata.json

@@ -1,14 +1,14 @@
 {
   "packageName": "meshy-node",
-  "packageVersion": "0.3.8",
+  "packageVersion": "0.3.9",
   "packages": {
     "workspace": {
       "name": "meshy",
-      "version": "0.3.8"
+      "version": "0.3.9"
     },
     "node": {
       "name": "meshy-node",
-      "version": "0.3.8"
+      "version": "0.3.9"
     },
     "core": {
       "name": "@meshy/core",
@@ -26,6 +26,6 @@
   "repository": {
     "url": "https://github.com/ai-microsoft/meshy",
     "branch": "supportTerminal",
-    "commit": "373ec48"
+    "commit": "0c23d39"
   }
 }