npm - meshy-node - Versions diffs - 0.3.9 → 0.4.0 - Mend

meshy-node 0.3.9 → 0.4.0

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

package/dashboard/assets/{input-CdkmqjGJ.js → input-DtRxMGzO.js} RENAMED Viewed

@@ -1,4 +1,4 @@
-import{c as s,r as t,j as a,b as n}from"./index-DHC5U3_j.js";/**
+import{c as s,r as t,j as a,b as n}from"./index-n69fx3B-.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-DHC5U3_j.js"></script>
-    <link rel="stylesheet" crossorigin href="/assets/index-DfiptIs_.css">
+    <script type="module" crossorigin src="/assets/index-n69fx3B-.js"></script>
+    <link rel="stylesheet" crossorigin href="/assets/index-Ch6zIZ6Y.css">
   </head>
   <body>
     <div id="root"></div>

package/main.cjs CHANGED Viewed

@@ -34569,6 +34569,10 @@ var NODE_KIND_BY_LEGACY = {
   "node-workdir-tree": "node.workdir.tree",
   "node-workdir-branch-info": "node.workdir.branch-info",
   "node-workdir-branch-create": "node.workdir.branch-create",
+  "node-terminal-session-start": "node.terminal.session.start",
+  "node-terminal-session-list": "node.terminal.session.list",
+  "node-terminal-session-get": "node.terminal.session.get",
+  "node-terminal-session-stop": "node.terminal.session.stop",
   "node-sessions-list": "node.sessions.list",
   devtunnel: "node.transport.set",
   "node-agent-upgrade": "node.agent.upgrade",
@@ -43074,7 +43078,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 NodeTerminalSessionStatusSchema = external_exports.enum(["running", "exited", "failed", "stopped"]);
 var NodeListQuery = external_exports.object({
   status: external_exports.enum(["online", "busy", "offline"]).optional(),
   capability: external_exports.string().optional()
@@ -43108,7 +43112,7 @@ var NodeNativeSessionsQuery = external_exports.object({
   agent: external_exports.enum(["codex", "claudecode"]),
   limit: external_exports.coerce.number().int().min(1).max(100).default(50)
 });
-var NodeTerminalExecuteBody = external_exports.object({
+var NodeTerminalSessionStartBody = external_exports.object({
   command: external_exports.string().trim().min(1),
   cwd: external_exports.string().trim().min(1).optional()
 });
@@ -43153,31 +43157,27 @@ var NodeNativeSessionsResponse = external_exports.object({
   agent: external_exports.enum(["codex", "claudecode"]),
   sessions: external_exports.array(NativeSessionSummarySchema)
 });
-var NodeTerminalExecuteResult = external_exports.object({
+var NodeTerminalSessionResponse = external_exports.object({
+  id: external_exports.string(),
   nodeId: external_exports.string(),
   cwd: external_exports.string(),
   command: external_exports.string(),
+  pid: external_exports.number().int().nullable(),
+  status: NodeTerminalSessionStatusSchema,
   exitCode: external_exports.number().int().nullable(),
+  signal: external_exports.string().nullable(),
   stdout: external_exports.string(),
   stderr: external_exports.string(),
+  startedAt: external_exports.number(),
+  updatedAt: external_exports.number(),
+  completedAt: external_exports.number().optional(),
   durationMs: external_exports.number().int().min(0),
-  timedOut: external_exports.boolean(),
   stdoutTruncated: external_exports.boolean(),
   stderrTruncated: external_exports.boolean()
 });
-var NodeTerminalExecuteResponse = external_exports.object({
-  id: external_exports.string(),
-  kind: external_exports.literal("terminal.execute"),
+var NodeTerminalSessionListResponse = external_exports.object({
   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()
+  sessions: external_exports.array(NodeTerminalSessionResponse)
 });
 var UpdateNodeBody = external_exports.object({
   name: external_exports.string().min(1).optional(),
@@ -44503,8 +44503,8 @@ function computeParentPath(rootPath, currentPath, useAbsolute) {
 }
 // ../../packages/api/src/node/node-operation-service.ts
-var fs16 = __toESM(require("fs"), 1);
-var path18 = __toESM(require("path"), 1);
+var fs15 = __toESM(require("fs"), 1);
+var path17 = __toESM(require("path"), 1);
 var import_node_crypto7 = require("crypto");
 // ../../packages/api/src/node/agent-upgrade-service.ts
@@ -44790,95 +44790,6 @@ 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) {
@@ -44942,8 +44853,8 @@ var FileNodeOperationStore = class {
   load() {
     if (this.loaded) return;
     this.loaded = true;
-    if (!fs16.existsSync(this.filePath)) return;
-    const raw = JSON.parse(fs16.readFileSync(this.filePath, "utf-8"));
+    if (!fs15.existsSync(this.filePath)) return;
+    const raw = JSON.parse(fs15.readFileSync(this.filePath, "utf-8"));
     const entries = Array.isArray(raw) ? raw : Object.values(raw);
     for (const entry of entries) {
       if (isNodeOperation(entry)) {
@@ -44952,14 +44863,14 @@ var FileNodeOperationStore = class {
     }
   }
   persist() {
-    fs16.mkdirSync(this.storagePath, { recursive: true });
+    fs15.mkdirSync(this.storagePath, { recursive: true });
     const body = JSON.stringify(Object.fromEntries(this.operations), null, 2);
     const tmpPath = `${this.filePath}.tmp`;
-    fs16.writeFileSync(tmpPath, body, "utf-8");
-    fs16.renameSync(tmpPath, this.filePath);
+    fs15.writeFileSync(tmpPath, body, "utf-8");
+    fs15.renameSync(tmpPath, this.filePath);
   }
   get filePath() {
-    return path18.join(this.storagePath, "node-operations.json");
+    return path17.join(this.storagePath, "node-operations.json");
   }
 };
 var NodeOperationService = class {
@@ -44967,7 +44878,6 @@ 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();
@@ -45113,15 +45023,6 @@ 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(
@@ -45279,7 +45180,7 @@ async function sendNodeWorkDirBranchCreateOperation(req, res, nodeId) {
 }
 // ../../packages/api/src/tasks/task-route-utils.ts
-var fs17 = __toESM(require("fs"), 1);
+var fs16 = __toESM(require("fs"), 1);
 var import_node_stream2 = require("stream");
 var import_promises5 = require("stream/promises");
@@ -45288,7 +45189,10 @@ var LEGACY_KIND_BY_NODE_MESSAGE = {
   "node.workdir.tree": "node-workdir-tree",
   "node.workdir.branch-info": "node-workdir-branch-info",
   "node.workdir.branch-create": "node-workdir-branch-create",
-  "node.terminal.execute": "node-terminal-execute",
+  "node.terminal.session.start": "node-terminal-session-start",
+  "node.terminal.session.list": "node-terminal-session-list",
+  "node.terminal.session.get": "node-terminal-session-get",
+  "node.terminal.session.stop": "node-terminal-session-stop",
   "node.sessions.list": "node-sessions-list",
   "node.transport.set": "devtunnel",
   "node.agent.upgrade": "node-agent-upgrade",
@@ -45304,9 +45208,13 @@ var LEGACY_KIND_BY_NODE_MESSAGE = {
 function canRequestNodeMessage(heartbeat) {
   return !!(heartbeat?.requestNodeMessage || heartbeat?.requestWorkerControl);
 }
-function requestFallbackNodeMessage(heartbeat, nodeId, message) {
-  if (heartbeat.requestNodeMessage) return heartbeat.requestNodeMessage(nodeId, message);
-  if (heartbeat.requestWorkerControl) return heartbeat.requestWorkerControl(nodeId, toLegacyWorkerControl2(message));
+function requestFallbackNodeMessage(heartbeat, nodeId, message, timeoutMs) {
+  if (heartbeat.requestNodeMessage) {
+    return timeoutMs === void 0 ? heartbeat.requestNodeMessage(nodeId, message) : heartbeat.requestNodeMessage(nodeId, message, timeoutMs);
+  }
+  if (heartbeat.requestWorkerControl) {
+    return timeoutMs === void 0 ? heartbeat.requestWorkerControl(nodeId, toLegacyWorkerControl2(message)) : heartbeat.requestWorkerControl(nodeId, toLegacyWorkerControl2(message), timeoutMs);
+  }
   throw new Error("Node message fallback is not available");
 }
 function toLegacyWorkerControl2(message) {
@@ -45334,10 +45242,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 (!fs17.existsSync(logPath)) {
+  if (!fs16.existsSync(logPath)) {
     return { logs: [], total: 0 };
   }
-  const content = fs17.readFileSync(logPath, "utf-8");
+  const content = fs16.readFileSync(logPath, "utf-8");
   const allLines = content.trim().split("\n").filter(Boolean);
   const logs = [];
   for (let i = after; i < allLines.length; i++) {
@@ -45567,6 +45475,193 @@ async function maybeProxyReadToLeader(req, res, options = {}) {
   }
 }
+// ../../packages/api/src/node/node-terminal-session-service.ts
+var import_node_child_process10 = require("child_process");
+var import_node_crypto8 = require("crypto");
+// ../../packages/api/src/node/node-terminal-service.ts
+var fs17 = __toESM(require("fs"), 1);
+var path18 = __toESM(require("path"), 1);
+var DEFAULT_OUTPUT_LIMIT_BYTES = 64 * 1024;
+function isAbsolutePath2(value) {
+  return path18.isAbsolute(value) || /^[A-Za-z]:[\/]/.test(value);
+}
+function resolveNodeTerminalCwd(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;
+}
+// ../../packages/api/src/node/node-terminal-session-service.ts
+var MAX_COMPLETED_SESSIONS = 10;
+function createOutputBuffer() {
+  return { chunks: [], bytes: 0, observedBytes: 0 };
+}
+function appendTail(buffer, chunk, limitBytes) {
+  buffer.observedBytes += chunk.length;
+  const nextChunk = chunk.length > limitBytes ? chunk.subarray(chunk.length - limitBytes) : chunk;
+  buffer.chunks.push(nextChunk);
+  buffer.bytes += nextChunk.length;
+  while (buffer.bytes > limitBytes && buffer.chunks.length > 0) {
+    const first = buffer.chunks[0];
+    if (!first) break;
+    const overflow = buffer.bytes - limitBytes;
+    if (first.length <= overflow) {
+      buffer.chunks.shift();
+      buffer.bytes -= first.length;
+      continue;
+    }
+    buffer.chunks[0] = first.subarray(overflow);
+    buffer.bytes -= overflow;
+  }
+}
+function readBuffer(buffer, limitBytes) {
+  return {
+    text: Buffer.concat(buffer.chunks, buffer.bytes).toString("utf8"),
+    truncated: buffer.observedBytes > limitBytes
+  };
+}
+function cloneSession(session) {
+  return { ...session };
+}
+function killSessionProcess(state3, signal) {
+  const child = state3.process;
+  if (!child) return;
+  const pid = child.pid;
+  if (process.platform !== "win32" && typeof pid === "number") {
+    try {
+      process.kill(-pid, signal);
+      return;
+    } catch {
+    }
+  }
+  try {
+    child.kill(signal);
+  } catch {
+  }
+}
+var NodeTerminalSessionService = class {
+  sessions = /* @__PURE__ */ new Map();
+  nextSequence = 0;
+  start(nodeId, rootPath, command, options = {}) {
+    const normalizedCommand = command.trim();
+    if (!normalizedCommand) {
+      throw new MeshyError("VALIDATION_ERROR", "Command must not be empty", 400);
+    }
+    const cwd = resolveNodeTerminalCwd(nodeId, rootPath, options.cwd);
+    const startedAt = Date.now();
+    const child = (0, import_node_child_process10.spawn)(normalizedCommand, {
+      cwd,
+      shell: true,
+      windowsHide: true,
+      stdio: ["ignore", "pipe", "pipe"],
+      detached: process.platform !== "win32"
+    });
+    const session = {
+      id: (0, import_node_crypto8.randomUUID)(),
+      nodeId,
+      cwd,
+      command: normalizedCommand,
+      pid: child.pid ?? null,
+      status: "running",
+      exitCode: null,
+      signal: null,
+      stdout: "",
+      stderr: "",
+      startedAt,
+      updatedAt: startedAt,
+      durationMs: 0,
+      stdoutTruncated: false,
+      stderrTruncated: false
+    };
+    const state3 = {
+      session,
+      process: child,
+      stdout: createOutputBuffer(),
+      stderr: createOutputBuffer(),
+      sequence: this.nextSequence++
+    };
+    const outputLimitBytes = options.outputLimitBytes ?? DEFAULT_OUTPUT_LIMIT_BYTES;
+    this.sessions.set(session.id, state3);
+    child.stdout?.on("data", (chunk) => {
+      appendTail(state3.stdout, chunk, outputLimitBytes);
+      this.refreshOutput(state3, outputLimitBytes);
+    });
+    child.stderr?.on("data", (chunk) => {
+      if (state3.session.status === "stopped") return;
+      appendTail(state3.stderr, chunk, outputLimitBytes);
+      this.refreshOutput(state3, outputLimitBytes);
+    });
+    child.on("error", (err) => {
+      state3.session.status = "failed";
+      state3.session.stderr = state3.session.stderr ? `${state3.session.stderr}
+${err.message}` : err.message;
+      this.complete(state3, null, null, outputLimitBytes);
+    });
+    child.on("close", (code, signal) => {
+      if (state3.session.status !== "stopped") {
+        state3.session.status = code === 0 ? "exited" : "failed";
+      }
+      this.complete(state3, code, signal, outputLimitBytes);
+    });
+    return cloneSession(session);
+  }
+  list() {
+    return Array.from(this.sessions.values()).sort((a, b) => b.sequence - a.sequence).map((state3) => cloneSession(state3.session));
+  }
+  get(id) {
+    const state3 = this.sessions.get(id);
+    return state3 ? cloneSession(state3.session) : null;
+  }
+  stop(id) {
+    const state3 = this.sessions.get(id);
+    if (!state3) return null;
+    if (state3.session.status === "running") {
+      state3.session.status = "stopped";
+      state3.session.updatedAt = Date.now();
+      killSessionProcess(state3, "SIGTERM");
+      setTimeout(() => {
+        if (state3.session.status === "stopped" && !state3.session.completedAt) {
+          killSessionProcess(state3, "SIGKILL");
+        }
+      }, 2e3).unref?.();
+    }
+    return cloneSession(state3.session);
+  }
+  refreshOutput(state3, outputLimitBytes) {
+    const stdout = readBuffer(state3.stdout, outputLimitBytes);
+    const stderr = readBuffer(state3.stderr, outputLimitBytes);
+    state3.session.stdout = stdout.text;
+    state3.session.stderr = stderr.text;
+    state3.session.stdoutTruncated = stdout.truncated;
+    state3.session.stderrTruncated = stderr.truncated;
+    state3.session.updatedAt = Date.now();
+    state3.session.durationMs = state3.session.updatedAt - state3.session.startedAt;
+  }
+  complete(state3, exitCode, signal, outputLimitBytes) {
+    this.refreshOutput(state3, outputLimitBytes);
+    state3.session.exitCode = exitCode;
+    state3.session.signal = signal;
+    state3.session.completedAt = Date.now();
+    state3.session.updatedAt = state3.session.completedAt;
+    state3.session.durationMs = state3.session.completedAt - state3.session.startedAt;
+    state3.process = null;
+    this.pruneCompletedSessions();
+  }
+  pruneCompletedSessions() {
+    const completed = Array.from(this.sessions.values()).filter((state3) => state3.session.status !== "running").sort((a, b) => b.sequence - a.sequence);
+    for (const state3 of completed.slice(MAX_COMPLETED_SESSIONS)) {
+      this.sessions.delete(state3.session.id);
+    }
+  }
+};
 // ../../packages/api/src/node/node-native-session-service.ts
 function getLocalNodeNativeSessions(nodeId, agent, limit) {
   return {
@@ -46651,6 +46746,10 @@ function payloadValue(request, key, fallback) {
   const value = request.payload[key];
   return value === void 0 ? fallback : value;
 }
+function getTerminalSessionService(deps) {
+  deps.terminalSessionService ??= new NodeTerminalSessionService();
+  return deps.terminalSessionService;
+}
 function maybeImportTaskSnapshot(deps, request) {
   if (!request.kind.startsWith("task.output.") && request.kind !== "task.preview.create" && request.kind !== "task.logs") return;
   const task = payloadValue(request, "task", null);
@@ -46728,12 +46827,12 @@ async function executeWorkerControlRequest(deps, request) {
         );
         break;
       }
-      case "node.terminal.execute": {
+      case "node.terminal.session.start": {
         const self2 = deps.nodeRegistry.getSelf();
         response = jsonResponse(
           request.id,
-          200,
-          await executeLocalNodeTerminalCommand(
+          202,
+          getTerminalSessionService(deps).start(
             self2.id,
             self2.workDir ?? deps.workDir,
             payloadValue(request, "command", ""),
@@ -46742,6 +46841,28 @@ async function executeWorkerControlRequest(deps, request) {
         );
         break;
       }
+      case "node.terminal.session.list": {
+        const self2 = deps.nodeRegistry.getSelf();
+        response = jsonResponse(request.id, 200, {
+          nodeId: self2.id,
+          sessions: getTerminalSessionService(deps).list()
+        });
+        break;
+      }
+      case "node.terminal.session.get": {
+        const sessionId = payloadValue(request, "sessionId", "");
+        const session = getTerminalSessionService(deps).get(sessionId);
+        if (!session) throw new MeshyError("NODE_NOT_FOUND", `Terminal session ${sessionId} not found`, 404);
+        response = jsonResponse(request.id, 200, session);
+        break;
+      }
+      case "node.terminal.session.stop": {
+        const sessionId = payloadValue(request, "sessionId", "");
+        const session = getTerminalSessionService(deps).stop(sessionId);
+        if (!session) throw new MeshyError("NODE_NOT_FOUND", `Terminal session ${sessionId} not found`, 404);
+        response = jsonResponse(request.id, 200, session);
+        break;
+      }
       case "node.sessions.list": {
         const self2 = deps.nodeRegistry.getSelf();
         response = jsonResponse(
@@ -46990,28 +47111,82 @@ async function sendNodeAgentUpgrade(req, res, nodeId, agentParam) {
 }
 // ../../packages/api/src/routes/node-terminal.ts
-async function sendNodeTerminalExecuteOperation(req, res, nodeId) {
-  const body = NodeTerminalExecuteBody.parse(req.body);
+var TERMINAL_SESSION_PROXY_TIMEOUT_MS = 1e4;
+function getTerminalSessionService2(deps) {
+  deps.terminalSessionService ??= new NodeTerminalSessionService();
+  return deps.terminalSessionService;
+}
+async function sendRemoteTerminalSessionRequest(req, res, nodeId, message) {
   const deps = req.app.locals.deps;
-  const { nodeRegistry } = deps;
-  const selfId = nodeRegistry.getSelf().id;
-  const node = nodeId === selfId ? nodeRegistry.getSelf() : nodeRegistry.getNode(nodeId);
+  const node = deps.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
-  });
-  if (nodeId === selfId) {
-    operations.runLocal(operation.id);
+  const heartbeat = deps.heartbeat;
+  const canPushToNode = heartbeat.canPushToNode?.(nodeId) ?? true;
+  let response;
+  if (!canPushToNode && canRequestNodeMessage(heartbeat)) {
+    response = await requestFallbackNodeMessage(heartbeat, nodeId, message, TERMINAL_SESSION_PROXY_TIMEOUT_MS);
   } else {
     try {
-      await dispatchNodeOperation(deps, operation, node);
+      response = await new NodeMessageClient({
+        logger: deps.logger,
+        timeoutMs: TERMINAL_SESSION_PROXY_TIMEOUT_MS
+      }).request(node, message);
     } catch (err) {
-      operations.markFailed(operation.id, err instanceof Error ? err.message : String(err));
+      if (canRequestNodeMessage(heartbeat)) {
+        response = await requestFallbackNodeMessage(heartbeat, nodeId, message, TERMINAL_SESSION_PROXY_TIMEOUT_MS);
+      } else {
+        throw new MeshyError("NODE_OFFLINE", `Cannot reach node ${nodeId} for terminal session control`, 502, {
+          error: err instanceof Error ? err.message : String(err)
+        });
+      }
     }
   }
-  res.status(202).json(operation);
+  sendWorkerControlResponse(res, response);
+}
+async function sendNodeTerminalSessionStart(req, res, nodeId) {
+  const body = NodeTerminalSessionStartBody.parse(req.body);
+  const deps = req.app.locals.deps;
+  const self2 = deps.nodeRegistry.getSelf();
+  if (nodeId !== self2.id) {
+    await sendRemoteTerminalSessionRequest(req, res, nodeId, createNodeMessage("node.terminal.session.start", {
+      command: body.command,
+      cwd: body.cwd
+    }, { expectsResponse: true }));
+    return;
+  }
+  const session = getTerminalSessionService2(deps).start(self2.id, self2.workDir ?? deps.workDir, body.command, { cwd: body.cwd });
+  res.status(202).json(session);
+}
+async function sendNodeTerminalSessionList(req, res, nodeId) {
+  const deps = req.app.locals.deps;
+  const self2 = deps.nodeRegistry.getSelf();
+  if (nodeId !== self2.id) {
+    await sendRemoteTerminalSessionRequest(req, res, nodeId, createNodeMessage("node.terminal.session.list", {}, { expectsResponse: true }));
+    return;
+  }
+  res.json({ nodeId: self2.id, sessions: getTerminalSessionService2(deps).list() });
+}
+async function sendNodeTerminalSessionGet(req, res, nodeId, sessionId) {
+  const deps = req.app.locals.deps;
+  const self2 = deps.nodeRegistry.getSelf();
+  if (nodeId !== self2.id) {
+    await sendRemoteTerminalSessionRequest(req, res, nodeId, createNodeMessage("node.terminal.session.get", { sessionId }, { expectsResponse: true }));
+    return;
+  }
+  const session = getTerminalSessionService2(deps).get(sessionId);
+  if (!session) throw new MeshyError("NODE_NOT_FOUND", `Terminal session ${sessionId} not found`, 404);
+  res.json(session);
+}
+async function sendNodeTerminalSessionStop(req, res, nodeId, sessionId) {
+  const deps = req.app.locals.deps;
+  const self2 = deps.nodeRegistry.getSelf();
+  if (nodeId !== self2.id) {
+    await sendRemoteTerminalSessionRequest(req, res, nodeId, createNodeMessage("node.terminal.session.stop", { sessionId }, { expectsResponse: true }));
+    return;
+  }
+  const session = getTerminalSessionService2(deps).stop(sessionId);
+  if (!session) throw new MeshyError("NODE_NOT_FOUND", `Terminal session ${sessionId} not found`, 404);
+  res.json(session);
 }
 // ../../packages/api/src/routes/nodes.ts
@@ -47339,9 +47514,17 @@ function createNodeRoutes() {
     }
     sendLocalNodeWorkDirBranchInfo(req, res, nodeId);
   }));
-  router.post("/:id/terminal/execute", asyncHandler3(async (req, res) => {
-    const nodeId = req.params.id;
-    await sendNodeTerminalExecuteOperation(req, res, nodeId);
+  router.get("/:id/terminal/sessions", asyncHandler3(async (req, res) => {
+    await sendNodeTerminalSessionList(req, res, req.params.id);
+  }));
+  router.post("/:id/terminal/sessions", asyncHandler3(async (req, res) => {
+    await sendNodeTerminalSessionStart(req, res, req.params.id);
+  }));
+  router.get("/:id/terminal/sessions/:sessionId", asyncHandler3(async (req, res) => {
+    await sendNodeTerminalSessionGet(req, res, req.params.id, req.params.sessionId);
+  }));
+  router.post("/:id/terminal/sessions/:sessionId/stop", asyncHandler3(async (req, res) => {
+    await sendNodeTerminalSessionStop(req, res, req.params.id, req.params.sessionId);
   }));
   router.post("/:id/workdir/branch", asyncHandler3(async (req, res) => {
     const nodeId = req.params.id;

package/package.json CHANGED Viewed

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