meshy-node 0.4.4 → 0.4.6

package/main.cjs

@@ -6629,8 +6629,8 @@ var require_node2 = __commonJS({
           }
           break;
         case "FILE":
-          var fs22 = require("fs");
-          stream2 = new fs22.SyncWriteStream(fd2, { autoClose: false });
+          var fs23 = require("fs");
+          stream2 = new fs23.SyncWriteStream(fd2, { autoClose: false });
           stream2._type = "fs";
           break;
         case "PIPE":
@@ -23749,8 +23749,8 @@ var require_view = __commonJS({
     "use strict";
     var debug = require_src2()("express:view");
     var path23 = require("path");
-    var fs22 = require("fs");
-    var dirname7 = path23.dirname;
+    var fs23 = require("fs");
+    var dirname8 = path23.dirname;
     var basename5 = path23.basename;
     var extname3 = path23.extname;
     var join17 = path23.join;
@@ -23789,7 +23789,7 @@ var require_view = __commonJS({
       for (var i = 0; i < roots.length && !path24; i++) {
         var root = roots[i];
         var loc = resolve15(root, name2);
-        var dir = dirname7(loc);
+        var dir = dirname8(loc);
         var file = basename5(loc);
         path24 = this.resolve(dir, file);
       }
@@ -23815,7 +23815,7 @@ var require_view = __commonJS({
     function tryStat(path24) {
       debug('stat "%s"', path24);
       try {
-        return fs22.statSync(path24);
+        return fs23.statSync(path24);
       } catch (e) {
         return void 0;
       }
@@ -24113,7 +24113,7 @@ var require_mime = __commonJS({
   "../../node_modules/.pnpm/mime@1.6.0/node_modules/mime/mime.js"(exports2, module2) {
     "use strict";
     var path23 = require("path");
-    var fs22 = require("fs");
+    var fs23 = require("fs");
     function Mime() {
       this.types = /* @__PURE__ */ Object.create(null);
       this.extensions = /* @__PURE__ */ Object.create(null);
@@ -24134,7 +24134,7 @@ var require_mime = __commonJS({
     };
     Mime.prototype.load = function(file) {
       this._loading = file;
-      var map = {}, content = fs22.readFileSync(file, "ascii"), lines = content.split(/[\r\n]+/);
+      var map = {}, content = fs23.readFileSync(file, "ascii"), lines = content.split(/[\r\n]+/);
       lines.forEach(function(line) {
         var fields = line.replace(/\s*#.*|^\s*|\s*$/g, "").split(/\s+/);
         map[fields.shift()] = fields;
@@ -24256,7 +24256,7 @@ var require_send = __commonJS({
     var escapeHtml2 = require_escape_html();
     var etag = require_etag();
     var fresh = require_fresh();
-    var fs22 = require("fs");
+    var fs23 = require("fs");
     var mime = require_mime();
     var ms = require_ms();
     var onFinished = require_on_finished();
@@ -24589,7 +24589,7 @@ var require_send = __commonJS({
       var i = 0;
       var self2 = this;
       debug('stat "%s"', path24);
-      fs22.stat(path24, function onstat(err, stat) {
+      fs23.stat(path24, function onstat(err, stat) {
         if (err && err.code === "ENOENT" && !extname3(path24) && path24[path24.length - 1] !== sep4) {
           return next(err);
         }
@@ -24604,7 +24604,7 @@ var require_send = __commonJS({
         }
         var p = path24 + "." + self2._extensions[i++];
         debug('stat "%s"', p);
-        fs22.stat(p, function(err2, stat) {
+        fs23.stat(p, function(err2, stat) {
           if (err2) return next(err2);
           if (stat.isDirectory()) return next();
           self2.emit("file", p, stat);
@@ -24622,7 +24622,7 @@ var require_send = __commonJS({
         }
         var p = join17(path24, self2._index[i]);
         debug('stat "%s"', p);
-        fs22.stat(p, function(err2, stat) {
+        fs23.stat(p, function(err2, stat) {
           if (err2) return next(err2);
           if (stat.isDirectory()) return next();
           self2.emit("file", p, stat);
@@ -24634,7 +24634,7 @@ var require_send = __commonJS({
     SendStream.prototype.stream = function stream(path24, options) {
       var self2 = this;
       var res = this.res;
-      var stream2 = fs22.createReadStream(path24, options);
+      var stream2 = fs23.createReadStream(path24, options);
       this.emit("stream", stream2);
       stream2.pipe(res);
       function cleanup() {
@@ -31894,11 +31894,11 @@ var processUtils = {
 // ../../node_modules/.pnpm/@azure+identity@4.13.1/node_modules/@azure/identity/dist/esm/credentials/azurePowerShellCredential.js
 var logger18 = credentialLogger("AzurePowerShellCredential");
 var isWindows = process.platform === "win32";
-function formatCommand(commandName) {
+function formatCommand(commandName2) {
   if (isWindows) {
-    return `${commandName}.exe`;
+    return `${commandName2}.exe`;
   } else {
-    return commandName;
+    return commandName2;
   }
 }
 async function runCommands(commands, timeout) {
@@ -33863,6 +33863,49 @@ var LeaderElection = class {
 var import_node_crypto5 = require("crypto");
 var fs4 = __toESM(require("fs"), 1);
 var path4 = __toESM(require("path"), 1);
+
+// ../../packages/core/src/tasks/task-join-snapshot.ts
+var JOIN_TASK_SNAPSHOT_PAYLOAD_KEY = "__meshyJoinSnapshot";
+var MAX_JOIN_TASK_ERROR_LENGTH = 2e3;
+function truncate(value, maxLength) {
+  if (value === null || value.length <= maxLength) {
+    return value;
+  }
+  return `${value.slice(0, maxLength)}...`;
+}
+function shouldIncludeTaskInJoinSnapshot(task, selfId) {
+  return task.assignedTo === null || task.assignedTo === selfId;
+}
+function createJoinTaskSnapshot(task, ownerNodeId) {
+  return {
+    ...task,
+    description: "",
+    payload: {
+      [JOIN_TASK_SNAPSHOT_PAYLOAD_KEY]: {
+        ownerNodeId,
+        version: 1
+      }
+    },
+    result: null,
+    error: truncate(task.error, MAX_JOIN_TASK_ERROR_LENGTH)
+  };
+}
+function buildJoinTaskSnapshots(tasks, ownerNodeId) {
+  return tasks.filter((task) => shouldIncludeTaskInJoinSnapshot(task, ownerNodeId)).map((task) => createJoinTaskSnapshot(task, ownerNodeId));
+}
+function getJoinTaskSnapshotOwnerId(task) {
+  const metadata = task.payload[JOIN_TASK_SNAPSHOT_PAYLOAD_KEY];
+  if (typeof metadata !== "object" || metadata === null) {
+    return null;
+  }
+  const ownerNodeId = metadata.ownerNodeId;
+  return typeof ownerNodeId === "string" && ownerNodeId.length > 0 ? ownerNodeId : null;
+}
+function isJoinTaskSnapshot(task) {
+  return getJoinTaskSnapshotOwnerId(task) !== null;
+}
+
+// ../../packages/core/src/tasks/task-engine.ts
 function nodeSupportsAgent(node, agent) {
   return !node.supportedAgents || node.supportedAgents.length === 0 || node.supportedAgents.includes(agent);
 }
@@ -34148,7 +34191,9 @@ var TaskEngine = class {
         if (now - task.updatedAt < backoff) continue;
       }
       const previousNodeId = this.previousAssignments.get(task.id);
-      const capableNodes = availableNodes.filter((node) => nodeSupportsAgent(node, task.agent));
+      const snapshotOwnerId = getJoinTaskSnapshotOwnerId(task);
+      const candidateNodes = snapshotOwnerId ? availableNodes.filter((node) => node.id === snapshotOwnerId) : availableNodes;
+      const capableNodes = candidateNodes.filter((node) => nodeSupportsAgent(node, task.agent));
       if (capableNodes.length === 0) continue;
       const targetNode = this.pickLeastBusyNode(capableNodes, nodeLoad, previousNodeId);
       if (!targetNode) continue;
@@ -36160,16 +36205,17 @@ var RestLeaderTaskReporter = class {
 var import_node_child_process2 = require("child_process");
 async function startWorkerTaskExecution(options) {
   const { taskEngine, engineRegistry, nodeRegistry, eventBus, logger: logger27, workDir, leaderReporter } = options;
-  const task = { ...options.task };
-  const existing = taskEngine.getTask(task.id);
+  const incomingTask = { ...options.task };
+  const existing = taskEngine.getTask(incomingTask.id);
   if (existing && hasExecutionAlreadyStarted(existing.status)) {
     logger27.warn("skipping duplicate task.execute for already-started task", {
-      taskId: task.id,
+      taskId: incomingTask.id,
       status: existing.status,
-      agent: task.agent
+      agent: incomingTask.agent
     });
     return existing;
   }
+  const task = getExecutionTask(incomingTask, existing);
   task.effectiveProjectPath = resolveTaskWorkDir(task.project, workDir);
   task.branch = getCurrentGitBranch(task.effectiveProjectPath) ?? task.branch ?? null;
   await taskEngine.executeTask(task);
@@ -36219,6 +36265,17 @@ async function startWorkerTaskExecution(options) {
   }
   return task;
 }
+function getExecutionTask(incomingTask, existing) {
+  if (!existing || !isJoinTaskSnapshot(incomingTask) || isJoinTaskSnapshot(existing)) {
+    return incomingTask;
+  }
+  return {
+    ...existing,
+    status: incomingTask.status,
+    assignedTo: incomingTask.assignedTo,
+    assignedNodeName: incomingTask.assignedNodeName
+  };
+}
 function hasExecutionAlreadyStarted(status) {
   return status === "running" || status === "completed" || status === "failed" || status === "cancelled" || status === "archived";
 }
@@ -37780,8 +37837,8 @@ ${joinErrors.map((e) => `  - ${e}`).join("\n")}`
         devtunnelEndpoint
       });
     }
-    const tasks = this.taskEngine.listTasks().tasks;
     const self2 = this.nodeRegistry.getSelf();
+    const tasks = buildJoinTaskSnapshots(this.taskEngine.listTasks().tasks, self2.id);
     const joinBody = {
       id: self2.id,
       endpoint: self2.endpoint,
@@ -37872,6 +37929,7 @@ ${joinErrors.map((e) => `  - ${e}`).join("\n")}`
         leaderEndpoint,
         selfId: self2.id
       });
+      persistNodeStartupJoin(this.config.storage.path, void 0);
       return;
     }
     if (leader && leaderEndpoint) {
@@ -37934,7 +37992,7 @@ ${joinErrors.map((e) => `  - ${e}`).join("\n")}`
     this.election.stop();
     try {
       const leaderEndpoint = this.nodeRegistry.getLeaderEndpoint();
-      if (leaderEndpoint) {
+      if (leaderEndpoint && !this.nodeRegistry.isLeader()) {
         this.logger.info("sending shutdown cluster leave request", {
           leaderEndpoint,
           nodeId: this.selfInfo.id
@@ -38835,7 +38893,7 @@ function isDirectRunPath(entryPath) {
 }
 
 // src/bootstrap/start-node.ts
-var nodePath2 = __toESM(require("path"), 1);
+var nodePath3 = __toESM(require("path"), 1);
 
 // ../../node_modules/.pnpm/zod@3.25.76/node_modules/zod/v3/external.js
 var external_exports = {};
@@ -42951,6 +43009,15 @@ var SystemAgentInfoSchema = external_exports.object({
     detail: external_exports.string().nullable().optional()
   }).optional()
 });
+var SystemRuntimeUpdateInfoSchema = external_exports.object({
+  packageName: external_exports.string(),
+  currentVersion: external_exports.string().nullable(),
+  latestVersion: external_exports.string().nullable(),
+  updateAvailable: external_exports.boolean(),
+  checkedAt: external_exports.string(),
+  restartMode: external_exports.enum(["package", "development"]),
+  detail: external_exports.string().nullable().optional()
+});
 var NodeSettingsSnapshotSchema = external_exports.object({
   collectedAt: external_exports.number(),
   version: external_exports.string(),
@@ -42959,6 +43026,7 @@ var NodeSettingsSnapshotSchema = external_exports.object({
   auth: SystemAuthInfoSchema.optional(),
   os: SystemOsInfoSchema.optional(),
   runtime: SystemRuntimeInfoSchema.optional(),
+  runtimeUpdate: SystemRuntimeUpdateInfoSchema.optional(),
   agents: external_exports.array(SystemAgentInfoSchema).optional(),
   startupRequirements: external_exports.object({
     lastCheckedAt: external_exports.string().optional(),
@@ -43020,6 +43088,7 @@ var JoinTaskSchema = external_exports.object({
   agent: external_exports.string(),
   project: external_exports.string().nullable(),
   effectiveProjectPath: external_exports.string().nullable(),
+  branch: external_exports.string().nullable().optional(),
   conversationKind: external_exports.enum(["meshyChat", "nativeSession"]).optional(),
   payload: external_exports.record(external_exports.unknown()),
   status: external_exports.enum(["pending", "assigned", "running", "completed", "failed", "cancelled", "archived"]),
@@ -43806,10 +43875,19 @@ function createClusterRoutes() {
     });
   }));
   router.post("/leave", asyncHandler(async (req, res) => {
-    const { nodeRegistry, logger: rootLogger } = req.app.locals.deps;
+    const { nodeRegistry, election, leaveCurrentCluster, logger: rootLogger } = req.app.locals.deps;
     const log2 = rootLogger.child("cluster/leave");
     const { nodeId } = req.body;
     log2.info("received cluster leave request", { nodeId });
+    if (!election.isLeader()) {
+      if (!leaveCurrentCluster) {
+        throw new MeshyError("VALIDATION_ERROR", "Leave flow is not available on this node", 501);
+      }
+      log2.info("handling cluster leave request as local follower detach", { requestedNodeId: nodeId });
+      await leaveCurrentCluster();
+      res.json({ ok: true });
+      return;
+    }
     nodeRegistry.removeNode(nodeId);
     res.json({ ok: true });
   }));
@@ -44755,6 +44833,7 @@ function buildNodeSettingsSnapshot(options) {
       storagePath: options.storagePath ?? null,
       localDashboardOrigin: options.localDashboardOrigin ?? null
     },
+    runtimeUpdate: options.runtimeUpdate,
     agents,
     startupRequirements: {
       lastCheckedAt: runtimeMetadata?.startupRequirementsLastCheckedAt,
@@ -44838,8 +44917,61 @@ function upgradeRuntimeAgentForDeps(deps, agent) {
   return result;
 }
 
+// ../../packages/api/src/node/runtime-restart-request.ts
+function parseRuntimeRestartRequest(value) {
+  const body = isRecord4(value) ? value : {};
+  const startArgs = parseRuntimeRestartStartArgs(body.startArgs);
+  return {
+    reason: body.reason === "update" ? "update" : "restart",
+    ...startArgs && { startArgs }
+  };
+}
+function parseRuntimeRestartStartArgs(value) {
+  if (value === void 0) return void 0;
+  if (!isRecord4(value)) {
+    throw new MeshyError("VALIDATION_ERROR", "Runtime restart startArgs must be an object", 400);
+  }
+  const startArgs = {};
+  if (value.port !== void 0) {
+    const port = value.port;
+    if (typeof port !== "number" || !Number.isInteger(port) || port <= 0) {
+      throw new MeshyError("VALIDATION_ERROR", "Runtime restart port must be a positive integer", 400);
+    }
+    startArgs.port = port;
+  }
+  for (const key of ["name", "join", "workDir", "config"]) {
+    const parsed = parseOptionalString(value[key], key);
+    if (parsed !== void 0) startArgs[key] = parsed;
+  }
+  if (value.transport !== void 0) {
+    if (value.transport !== "direct" && value.transport !== "devtunnel" && value.transport !== "tailscale") {
+      throw new MeshyError("VALIDATION_ERROR", "Runtime restart transport must be direct, devtunnel, or tailscale", 400);
+    }
+    startArgs.transport = value.transport;
+  }
+  if (value.disableAuth !== void 0) {
+    if (typeof value.disableAuth !== "boolean") {
+      throw new MeshyError("VALIDATION_ERROR", "Runtime restart disableAuth must be a boolean", 400);
+    }
+    startArgs.disableAuth = value.disableAuth;
+  }
+  return Object.keys(startArgs).length > 0 ? startArgs : void 0;
+}
+function parseOptionalString(value, key) {
+  if (value === void 0) return void 0;
+  if (typeof value !== "string") {
+    throw new MeshyError("VALIDATION_ERROR", `Runtime restart ${key} must be a string`, 400);
+  }
+  const trimmed = value.trim();
+  return trimmed || void 0;
+}
+function isRecord4(value) {
+  return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+
 // ../../packages/api/src/node/node-operation-service.ts
 var LEADER_REPORT_RETRY_MS = 5e3;
+var OPERATION_COMMIT_EFFECT = /* @__PURE__ */ Symbol("operationCommitEffect");
 var NodeOperationFailure = class extends Error {
   constructor(message, result) {
     super(message);
@@ -44873,6 +45005,7 @@ var NodeOperationService = class {
     this.deps = deps;
     this.store = store;
     this.registerHandler("agent.upgrade", runAgentUpgradeOperation);
+    this.registerHandler("runtime.restart", runRuntimeRestartOperation);
     this.registerHandler("workdir.branch-create", runWorkDirBranchCreateOperation);
   }
   handlers = /* @__PURE__ */ new Map();
@@ -44943,8 +45076,14 @@ var NodeOperationService = class {
     try {
       const handler = this.handlers.get(running.kind);
       if (!handler) throw new Error(`No node operation handler registered for kind: ${running.kind}`);
-      const result = await handler(running, this.deps);
-      this.update(id, { status: "succeeded", result, completedAt: Date.now() });
+      const handled = readOperationCommitEffect(await handler(running, this.deps));
+      const saved = this.update(id, { status: "succeeded", result: handled.result, completedAt: Date.now() }, {
+        reportToLeader: handled.afterCommit ? false : true
+      });
+      if (handled.afterCommit) {
+        if (saved) await this.reportToLeader(saved);
+        await handled.afterCommit();
+      }
     } catch (err) {
       this.update(id, {
         status: "failed",
@@ -44954,12 +45093,12 @@ var NodeOperationService = class {
       });
     }
   }
-  update(id, updates) {
+  update(id, updates, options = {}) {
     const saved = this.store.update(id, { ...updates, updatedAt: Date.now() });
     if (!saved) return null;
     this.applyOperationSideEffects(saved);
     this.deps.eventBus.emit("node.operation.updated", { operation: saved });
-    void this.reportToLeader(saved);
+    if (options.reportToLeader !== false) void this.reportToLeader(saved);
     return saved;
   }
   applyOperationSideEffects(operation) {
@@ -45040,6 +45179,24 @@ function runAgentUpgradeOperation(operation, deps) {
   }
   return result;
 }
+function runRuntimeRestartOperation(operation, deps) {
+  if (!deps.restartRuntime) throw new Error("Runtime restart is not available for this node");
+  const reason = readPayloadString(operation, "reason") === "update" ? "update" : "restart";
+  const startArgs = readPayloadStartArgs(operation);
+  return deps.restartRuntime({ reason, ...startArgs && { startArgs }, deferShutdown: true }).then(
+    ({ completeShutdown, ...result }) => operationCommitEffect(result, completeShutdown)
+  );
+}
+function operationCommitEffect(result, afterCommit) {
+  return { [OPERATION_COMMIT_EFFECT]: true, result, afterCommit };
+}
+function readOperationCommitEffect(value) {
+  if (value && typeof value === "object" && value[OPERATION_COMMIT_EFFECT]) {
+    const effect = value;
+    return { result: effect.result, afterCommit: effect.afterCommit };
+  }
+  return { result: value };
+}
 function runWorkDirBranchCreateOperation(operation, deps) {
   const self2 = deps.nodeRegistry.getSelf();
   return createLocalNodeWorkDirBranch(
@@ -45073,6 +45230,11 @@ function readPayloadBoolean(operation, key, fallback) {
   const value = payload[key];
   return typeof value === "boolean" ? value : fallback;
 }
+function readPayloadStartArgs(operation) {
+  const payload = operation.payload;
+  if (!payload || typeof payload !== "object") return void 0;
+  return parseRuntimeRestartStartArgs(payload.startArgs);
+}
 function readSettingsSnapshot(value) {
   if (!value || typeof value !== "object") return void 0;
   const snapshot = value.settingsSnapshot;
@@ -45240,7 +45402,7 @@ function toLegacyWorkerControl2(message) {
 }
 
 // ../../packages/api/src/tasks/task-route-utils.ts
-function isRecord4(value) {
+function isRecord5(value) {
   return typeof value === "object" && value !== null;
 }
 function restoreTaskState(taskEngine, task) {
@@ -45307,7 +45469,7 @@ function normalizeStructuredValue(value) {
   if (Array.isArray(value)) {
     return value.map((entry) => normalizeStructuredValue(entry));
   }
-  if (!isRecord4(value)) {
+  if (!isRecord5(value)) {
     return value;
   }
   return Object.fromEntries(
@@ -45316,20 +45478,20 @@ function normalizeStructuredValue(value) {
 }
 function getTranscriptEventSignature(event) {
   if (event.type === "user") {
-    const signature = getTaskUserMessageSignature(isRecord4(event.message) ? event.message.content : event.message) ?? getTaskUserMessageSignature(event.content);
+    const signature = getTaskUserMessageSignature(isRecord5(event.message) ? event.message.content : event.message) ?? getTaskUserMessageSignature(event.content);
     return signature ? `user:${signature}` : null;
   }
   if (event.type === "assistant") {
     if (typeof event.message === "string") {
       return `assistant:${JSON.stringify(event.message)}`;
     }
-    if (isRecord4(event.message) && "content" in event.message) {
+    if (isRecord5(event.message) && "content" in event.message) {
       return `assistant:${JSON.stringify(normalizeStructuredValue(event.message.content))}`;
     }
     if (Array.isArray(event.content)) {
       return `assistant:${JSON.stringify(normalizeStructuredValue(event.content))}`;
     }
-    if (isRecord4(event.message)) {
+    if (isRecord5(event.message)) {
       return `assistant:${JSON.stringify(normalizeStructuredValue(event.message))}`;
     }
   }
@@ -47125,6 +47287,34 @@ async function sendNodeAgentUpgrade(req, res, nodeId, agentParam) {
   res.status(202).json(operation);
 }
 
+// ../../packages/api/src/routes/node-runtime.ts
+async function sendNodeRuntimeRestart(req, res, nodeId) {
+  const deps = req.app.locals.deps;
+  const self2 = deps.nodeRegistry.getSelf();
+  const isSelf = nodeId === self2.id;
+  if (!isSelf && !deps.election.isLeader()) {
+    throw new MeshyError("NOT_LEADER", "Only the leader can restart other nodes", 403);
+  }
+  const node = isSelf ? self2 : deps.nodeRegistry.getNode(nodeId);
+  if (!node) {
+    throw new MeshyError("NODE_NOT_FOUND", `Node ${nodeId} not found`, 404);
+  }
+  const restartRequest = parseRuntimeRestartRequest(req.body);
+  const operations = getNodeOperationService(deps);
+  const operation = operations.create("runtime.restart", nodeId, { ...restartRequest });
+  if (isSelf) {
+    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 restart runtime`, 502);
+    }
+  }
+  res.status(202).json(operation);
+}
+
 // ../../packages/api/src/routes/node-terminal.ts
 var TERMINAL_SESSION_PROXY_TIMEOUT_MS = 1e4;
 function getTerminalSessionService2(deps) {
@@ -47548,6 +47738,9 @@ function createNodeRoutes() {
   router.post("/:id/agents/:agent/upgrade", asyncHandler3(async (req, res) => {
     await sendNodeAgentUpgrade(req, res, req.params.id, req.params.agent);
   }));
+  router.post("/:id/runtime/restart", asyncHandler3(async (req, res) => {
+    await sendNodeRuntimeRestart(req, res, req.params.id);
+  }));
   router.patch("/:id", asyncHandler3(async (req, res) => {
     const { nodeRegistry, persistNodeNamePreference } = req.app.locals.deps;
     const updates = UpdateNodeBody.parse(req.body);
@@ -48029,8 +48222,10 @@ async function sendTaskLogsResponse(req, res, taskId) {
   if (!task && !proxyRequest.isProxy && await maybeProxyReadToLeader(req, res)) return;
   const selfId = nodeRegistry.getSelf()?.id;
   const isLeader = nodeRegistry.isLeader();
+  const snapshotOwnerId = task ? getJoinTaskSnapshotOwnerId(task) : null;
+  const proxyNodeId = task?.assignedTo ?? snapshotOwnerId;
   const isFollowerRemoteTask = !isLeader && !!(task?.assignedTo && task.assignedTo !== selfId);
-  const needsProxy = isLeader && !!(task?.assignedTo && task.assignedTo !== selfId);
+  const needsProxy = isLeader && !!(proxyNodeId && proxyNodeId !== selfId);
   if (proxyRequest.isProxy) {
     log2.info("received proxied task logs request", {
       taskId,
@@ -48048,6 +48243,7 @@ async function sendTaskLogsResponse(req, res, taskId) {
   log2.debug("log request", {
     taskId,
     assignedTo: task?.assignedTo,
+    snapshotOwnerId,
     selfId,
     isLeader,
     needsProxy
@@ -48071,20 +48267,21 @@ async function sendTaskLogsResponse(req, res, taskId) {
       selfId
     });
   }
-  const assignedTo = task.assignedTo;
-  if (needsProxy && assignedTo) {
-    const node = nodeRegistry.getNode(assignedTo);
+  if (needsProxy && proxyNodeId) {
+    const node = nodeRegistry.getNode(proxyNodeId);
     log2.debug("proxy target", { nodeId: node?.id, endpoint: node?.endpoint, devtunnel: node?.devtunnelEndpoint, status: node?.status });
     if (node) {
-      const seededLogs = await seedTaskSnapshotOnWorker(task, [], node, log2).catch((err) => {
-        log2.warn("failed to seed task snapshot before task logs proxy", {
-          taskId,
-          assignedTo,
-          ...describeProxyError3(err)
+      if (task.assignedTo === proxyNodeId && !snapshotOwnerId) {
+        const seededLogs = await seedTaskSnapshotOnWorker(task, [], node, log2).catch((err) => {
+          log2.warn("failed to seed task snapshot before task logs proxy", {
+            taskId,
+            assignedTo: proxyNodeId,
+            ...describeProxyError3(err)
+          });
+          return [];
         });
-        return [];
-      });
-      if (seededLogs.length > 0) recordLocalTaskLogs(engineRegistry, task, seededLogs);
+        if (seededLogs.length > 0) recordLocalTaskLogs(engineRegistry, task, seededLogs);
+      }
       const proxyPath = `/api/tasks/${taskId}/logs?after=${after}`;
       try {
         const { endpoint, response: proxyRes } = await fetchNodeWithFallback(
@@ -48098,7 +48295,7 @@ async function sendTaskLogsResponse(req, res, taskId) {
         const proxyUrl = `${endpoint}${proxyPath}`;
         log2.info("proxying task logs request", {
           taskId,
-          assignedTo,
+          assignedTo: proxyNodeId,
           endpoint,
           proxyPath,
           url: proxyUrl
@@ -48111,11 +48308,11 @@ async function sendTaskLogsResponse(req, res, taskId) {
       } catch (err) {
         log2.warn("task logs proxy failed; falling back to keepalive control", {
           taskId,
-          assignedTo,
+          assignedTo: proxyNodeId,
           timeoutMs: TASK_LOG_PROXY_TIMEOUT_MS,
           ...describeProxyError3(err)
         });
-        const fallback = await requestTaskLogsOverKeepalive(heartbeat, assignedTo, task, after);
+        const fallback = await requestTaskLogsOverKeepalive(heartbeat, proxyNodeId, task, after);
         if (fallback) {
           sendWorkerControlResponse(res, fallback);
           return;
@@ -48506,6 +48703,8 @@ var TERMINAL_STATUSES3 = /* @__PURE__ */ new Set(["completed", "failed", "cancel
 var ARCHIVABLE_STATUSES = /* @__PURE__ */ new Set(["completed", "failed", "cancelled", "archived"]);
 var ACTIVE_STATUSES = /* @__PURE__ */ new Set(["pending", "assigned", "running"]);
 var TASK_DELETE_NOTIFY_TIMEOUT_MS = 1500;
+var TASK_DETAIL_PROXY_TIMEOUT_MS = 1e4;
+var TASK_DETAIL_PROXY_HEADER = "x-meshy-task-detail-proxy";
 function shouldGenerateTitle(task) {
   return task.payload.titleSource === "derived";
 }
@@ -48616,6 +48815,62 @@ function withShareMetadata(task, taskEngine, shareOrigin) {
 function toTaskResponse(task, nodeRegistry, taskEngine, shareOrigin) {
   return withShareMetadata(withAssignedNodeMetadata(task, nodeRegistry), taskEngine, shareOrigin);
 }
+async function proxyJoinSnapshotTaskDetail(deps) {
+  if (deps.req.get(TASK_DETAIL_PROXY_HEADER) === "1") {
+    return null;
+  }
+  const ownerNodeId = getJoinTaskSnapshotOwnerId(deps.task);
+  const selfId = deps.nodeRegistry.getSelf()?.id;
+  if (!ownerNodeId || ownerNodeId === selfId) {
+    return null;
+  }
+  const owner = deps.nodeRegistry.getNode(ownerNodeId);
+  const log2 = deps.logger.child("tasks/detail");
+  if (!owner) {
+    log2.warn("join snapshot owner is unavailable for task detail proxy", {
+      taskId: deps.task.id,
+      ownerNodeId
+    });
+    return null;
+  }
+  const proxyPath = `/api/tasks/${encodeURIComponent(deps.task.id)}`;
+  try {
+    const { endpoint, response } = await fetchNodeWithFallback(
+      owner,
+      proxyPath,
+      { method: "GET", headers: { [TASK_DETAIL_PROXY_HEADER]: "1" } },
+      TASK_DETAIL_PROXY_TIMEOUT_MS,
+      void 0,
+      { preferPublicEndpoint: true }
+    );
+    if (!response.ok) {
+      log2.warn("join snapshot task detail proxy returned non-ok response", {
+        taskId: deps.task.id,
+        ownerNodeId,
+        endpoint,
+        statusCode: response.status
+      });
+      return null;
+    }
+    const fullTask = await response.json();
+    if (fullTask.id !== deps.task.id) {
+      log2.warn("join snapshot task detail proxy returned a different task id", {
+        taskId: deps.task.id,
+        ownerNodeId,
+        returnedTaskId: fullTask.id
+      });
+      return null;
+    }
+    return fullTask;
+  } catch (err) {
+    log2.warn("join snapshot task detail proxy failed", {
+      taskId: deps.task.id,
+      ownerNodeId,
+      error: err instanceof Error ? err.message : String(err)
+    });
+    return null;
+  }
+}
 function buildShareUrl(origin, shareId) {
   return `${origin.replace(/\/+$/, "")}/shared/tasks/${encodeURIComponent(shareId)}`;
 }
@@ -48739,14 +48994,15 @@ function createTaskRoutes() {
     res.json({ results });
   }));
   router.get("/:id", asyncHandler6(async (req, res) => {
-    const { taskEngine, nodeRegistry, shareOrigin } = req.app.locals.deps;
+    const { taskEngine, nodeRegistry, shareOrigin, logger: logger27 } = req.app.locals.deps;
     const taskId = req.params.id;
     const task = taskEngine.getTask(taskId);
     if (!task) {
       if (await maybeProxyReadToLeader(req, res)) return;
       throw new MeshyError("TASK_NOT_FOUND", `Task ${taskId} not found`, 404);
     }
-    res.json(toTaskResponse(task, nodeRegistry, taskEngine, shareOrigin));
+    const fullTask = await proxyJoinSnapshotTaskDetail({ task, req, logger: logger27, nodeRegistry });
+    res.json(toTaskResponse(fullTask ?? task, nodeRegistry, taskEngine, shareOrigin));
   }));
   router.post("/:id/share", asyncHandler6(async (req, res) => {
     const { taskEngine, ensureShareTunnel } = req.app.locals.deps;
@@ -49378,7 +49634,8 @@ function createSystemRoutes() {
       localDashboardOrigin,
       storagePath,
       inspectRuntimeTools: inspectTools,
-      runtimeMetadata
+      runtimeMetadata,
+      runtimeUpdate
     } = req.app.locals.deps;
     const self2 = nodeRegistry.getSelf();
     const auth = config.authMetadata ?? {
@@ -49391,6 +49648,7 @@ function createSystemRoutes() {
       inspectRuntimeTools: inspectTools,
       localDashboardOrigin,
       runtimeMetadata,
+      runtimeUpdate,
       storagePath,
       workDir: self2.workDir
     });
@@ -49406,6 +49664,7 @@ function createSystemRoutes() {
       auth: settingsSnapshot.auth,
       os: settingsSnapshot.os,
       runtime: settingsSnapshot.runtime,
+      runtimeUpdate: settingsSnapshot.runtimeUpdate,
       agents: settingsSnapshot.agents,
       startupRequirements: settingsSnapshot.startupRequirements,
       components: settingsSnapshot.components,
@@ -49413,6 +49672,23 @@ function createSystemRoutes() {
       packages: settingsSnapshot.packages
     });
   }));
+  router.post("/runtime/restart", asyncHandler9(async (req, res) => {
+    const { restartRuntime } = req.app.locals.deps;
+    if (!restartRuntime) {
+      throw new MeshyError("VALIDATION_ERROR", "Runtime restart is not available for this node", 501);
+    }
+    const restartRequest = parseRuntimeRestartRequest(req.body);
+    const result = await restartRuntime(restartRequest);
+    res.status(202).json(result);
+  }));
+  router.post("/runtime/stop", asyncHandler9(async (req, res) => {
+    const { stopRuntime } = req.app.locals.deps;
+    if (!stopRuntime) {
+      throw new MeshyError("VALIDATION_ERROR", "Runtime stop is not available for this node", 501);
+    }
+    const result = await stopRuntime();
+    res.status(202).json(result);
+  }));
   router.post("/transport", asyncHandler9(async (req, res) => {
     const { switchTransport } = req.app.locals.deps;
     if (!switchTransport) {
@@ -49581,6 +49857,9 @@ function createNodeOperationRoutes() {
 var JSON_BODY_LIMIT = "1mb";
 var JSON_BODY_LIMIT_LARGE = "25mb";
 var TRUSTED_LOCAL_HOSTS2 = /* @__PURE__ */ new Set(["localhost", "127.0.0.1", "[::1]", "::1"]);
+function usesLargeJsonBodyLimit(pathname) {
+  return pathname === "/api/cluster/join" || pathname === "/api/node" || pathname.startsWith("/api/node/") || pathname === "/api/tasks" || pathname.startsWith("/api/tasks/") || pathname === "/api/worker" || pathname.startsWith("/api/worker/");
+}
 function normalizeHost2(value) {
   const trimmed = value?.trim().toLowerCase();
   return trimmed ? trimmed.replace(/:\d+$/, "") : void 0;
@@ -49707,7 +49986,12 @@ function createServer2(deps) {
       staticMiddleware(req, res, next);
     });
   }
-  app.use(import_express14.default.json({ limit: JSON_BODY_LIMIT }));
+  const defaultJsonParser = import_express14.default.json({ limit: JSON_BODY_LIMIT });
+  const largeJsonParser = import_express14.default.json({ limit: JSON_BODY_LIMIT_LARGE });
+  app.use((req, res, next) => {
+    const parser = usesLargeJsonBodyLimit(req.path) ? largeJsonParser : defaultJsonParser;
+    parser(req, res, next);
+  });
   app.use(createAuthMiddleware(authConfig));
   app.use((req, res, next) => {
     void (async () => {
@@ -49733,14 +50017,13 @@ function createServer2(deps) {
     taskEngine: deps.taskEngine,
     logger: deps.logger
   }));
-  const largeBodyParser = import_express14.default.json({ limit: JSON_BODY_LIMIT_LARGE });
   app.use("/api/cluster", createClusterRoutes());
   app.use("/api/cluster-control", createClusterControlRoutes());
-  app.use("/api/node", largeBodyParser, createNodeMessageRoutes());
+  app.use("/api/node", createNodeMessageRoutes());
   app.use("/api/nodes", createNodeRoutes());
-  app.use("/api/tasks", largeBodyParser, createTaskRoutes());
+  app.use("/api/tasks", createTaskRoutes());
   app.use("/api/shared", createSharedRoutes());
-  app.use("/api/worker", largeBodyParser, createWorkerRoutes());
+  app.use("/api/worker", createWorkerRoutes());
   app.use("/api/system", createSystemRoutes());
   app.use("/api/node-operations", createNodeOperationRoutes());
   app.use("/api/events", createEventRoutes());
@@ -50780,6 +51063,346 @@ function buildRuntimeMetadata(storagePath) {
   };
 }
 
+// src/bootstrap/runtime-restart.ts
+var fs22 = __toESM(require("fs"), 1);
+var nodePath2 = __toESM(require("path"), 1);
+var import_node_child_process14 = require("child_process");
+function resolveRuntimeRestartStartArgs(hydratedArgs, restartArgs) {
+  return restartArgs ? { ...restartArgs } : hydratedArgs;
+}
+var runtimeUpdateCache = /* @__PURE__ */ new Map();
+var RESTARTER_SOURCE = String.raw`
+const { spawn } = require('node:child_process');
+const http = require('node:http');
+
+const plan = JSON.parse(process.env.MESHY_RESTART_PLAN || '{}');
+const parentPid = Number(process.env.MESHY_RESTART_PARENT_PID || '0');
+
+function log(message) {
+  process.stdout.write('[' + new Date().toISOString() + '] ' + message + '\n');
+}
+
+function sleep(ms) {
+  return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+function isProcessAlive(pid) {
+  if (!pid) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function requestHealth(url) {
+  return new Promise(resolve => {
+    const req = http.get(url, res => {
+      res.resume();
+      res.on('end', () => resolve(res.statusCode >= 200 && res.statusCode < 500));
+    });
+    req.setTimeout(1000, () => {
+      req.destroy();
+      resolve(false);
+    });
+    req.on('error', () => resolve(false));
+  });
+}
+
+async function waitForParentExit() {
+  const deadline = Date.now() + 30000;
+  while (isProcessAlive(parentPid) && Date.now() < deadline) {
+    await sleep(250);
+  }
+}
+
+async function waitForEndpointDown() {
+  if (!plan.healthUrl) return;
+  const deadline = Date.now() + 30000;
+  while (Date.now() < deadline) {
+    if (!await requestHealth(plan.healthUrl)) return;
+    await sleep(250);
+  }
+}
+
+(async () => {
+  log('waiting to restart ' + (plan.displayCommand || plan.command));
+  await waitForParentExit();
+  await waitForEndpointDown();
+  log('starting ' + (plan.displayCommand || plan.command));
+  const child = spawn(plan.command, plan.args || [], {
+    cwd: plan.cwd,
+    env: { ...process.env, ...(plan.env || {}), MESHY_RESTART_CHILD: '1' },
+    detached: true,
+    stdio: ['ignore', 'inherit', 'inherit'],
+    windowsHide: true,
+  });
+  child.on('error', error => {
+    log('failed to launch restart command: ' + (error && error.message ? error.message : String(error)));
+    process.exitCode = 1;
+  });
+  child.unref();
+  await sleep(500);
+})().catch(error => {
+  log('restart helper failed: ' + (error && error.message ? error.message : String(error)));
+  process.exit(1);
+});
+`;
+function formatLocalDate3(date) {
+  const year = date.getFullYear();
+  const month = String(date.getMonth() + 1).padStart(2, "0");
+  const day = String(date.getDate()).padStart(2, "0");
+  return `${year}-${month}-${day}`;
+}
+function normalizeOutput2(output) {
+  if (!output) return null;
+  const firstLine = output.split(/\r?\n/).map((line) => line.trim()).find(Boolean);
+  return firstLine ?? null;
+}
+function normalizePackageVersion2(output) {
+  const normalized = normalizeOutput2(output);
+  if (!normalized) return null;
+  try {
+    const parsed = JSON.parse(normalized);
+    return typeof parsed === "string" ? parsed.trim() || null : normalized;
+  } catch {
+    return normalized;
+  }
+}
+function compareSemver2(left, right) {
+  const leftParts = left.split(/[.-]/).map((part) => Number.parseInt(part, 10));
+  const rightParts = right.split(/[.-]/).map((part) => Number.parseInt(part, 10));
+  for (let index = 0; index < 3; index += 1) {
+    const delta = (leftParts[index] || 0) - (rightParts[index] || 0);
+    if (delta !== 0) return delta;
+  }
+  return 0;
+}
+function runRuntimePackageCommand(command, args) {
+  const result = (0, import_node_child_process14.spawnSync)(command, args, {
+    encoding: "utf-8",
+    windowsHide: true,
+    timeout: 2500
+  });
+  return {
+    status: result.status,
+    stdout: typeof result.stdout === "string" ? result.stdout : "",
+    stderr: typeof result.stderr === "string" ? result.stderr : "",
+    error: result.error?.message ?? null
+  };
+}
+function commandName(base, platform2) {
+  return platform2 === "win32" ? `${base}.cmd` : base;
+}
+function pathForPlatform(platform2) {
+  return platform2 === "win32" ? nodePath2.win32 : nodePath2;
+}
+function resolveDevelopmentRepoRoot(cwd, env, platform2) {
+  if (env.MESHY_STORAGE_BASE_DIR) return env.MESHY_STORAGE_BASE_DIR;
+  const pathApi = pathForPlatform(platform2);
+  const packageDir = pathApi.basename(cwd);
+  const packageParent = pathApi.basename(pathApi.dirname(cwd));
+  return packageDir === "node" && packageParent === "apps" ? pathApi.dirname(pathApi.dirname(cwd)) : cwd;
+}
+function windowsShellQuote(value) {
+  return /[\s&()^|<>"]/.test(value) ? `"${value.replace(/"/g, '\\"')}"` : value;
+}
+function createSpawnableCommand(command, args, platform2) {
+  const displayCommand = [command, ...args].map(shellQuote).join(" ");
+  if (platform2 !== "win32") return { command, args, displayCommand };
+  return {
+    command: "cmd.exe",
+    args: ["/d", "/s", "/c", [command, ...args].map(windowsShellQuote).join(" ")],
+    displayCommand
+  };
+}
+function readProcessCommand(pid, platform2) {
+  if (platform2 === "win32") return null;
+  const result = (0, import_node_child_process14.spawnSync)("ps", ["-p", String(pid), "-o", "args="], {
+    encoding: "utf-8",
+    windowsHide: true,
+    timeout: 1e3
+  });
+  return result.status === 0 && typeof result.stdout === "string" ? result.stdout.trim() || null : null;
+}
+function isNodeWatchCommand(command) {
+  return /(?:^|[/\\])node(?:\.exe)?(?:\s|$)/.test(command) && /(?:^|\s)--watch(?:=|\s|$)/.test(command);
+}
+function terminateRuntimeWatchParent(options) {
+  if (options.mode !== "development") return { terminated: false, reason: "not-development" };
+  const parentPid = options.parentPid ?? process.ppid;
+  if (!Number.isInteger(parentPid) || parentPid <= 1 || parentPid === process.pid) {
+    return { terminated: false, reason: "invalid-parent" };
+  }
+  const commandReader = options.commandReader ?? ((pid) => readProcessCommand(pid, options.platform ?? process.platform));
+  const parentCommand = commandReader(parentPid);
+  const parentIsWatch = parentCommand !== null ? isNodeWatchCommand(parentCommand) : options.env?.WATCH_REPORT_DEPENDENCIES === "1";
+  if (!parentIsWatch) return { terminated: false, reason: "parent-not-watch" };
+  try {
+    const kill = options.kill ?? process.kill;
+    kill(parentPid, "SIGINT");
+    return { terminated: true, pid: parentPid };
+  } catch {
+    return { terminated: false, reason: "kill-failed" };
+  }
+}
+function compactEnv(env) {
+  const result = {};
+  for (const [key, value] of Object.entries(env)) {
+    if (typeof value === "string") result[key] = value;
+  }
+  return result;
+}
+function shellQuote(value) {
+  return /\s/.test(value) ? JSON.stringify(value) : value;
+}
+function formatStartArgs(args) {
+  const result = ["start"];
+  if (args.port !== void 0) result.push("--port", String(args.port));
+  if (args.name) result.push("--name", args.name);
+  if (args.join) result.push("--join", args.join);
+  if (args.transport) result.push("--transport", args.transport);
+  if (args.workDir) result.push("--work-dir", args.workDir);
+  if (args.config) result.push("--config", args.config);
+  if (args.disableAuth) result.push("--disable-auth");
+  return result;
+}
+function detectRuntimeRestartMode(env = process.env, entryPath = process.argv[1]) {
+  if (env.MESHY_RESTART_MODE === "package" || env.MESHY_RESTART_MODE === "development") {
+    return env.MESHY_RESTART_MODE;
+  }
+  if (env.MESHY_STORAGE_MODE === "cwd" && env.MESHY_STORAGE_BASE_DIR) {
+    return "development";
+  }
+  return typeof entryPath === "string" && /src[/\\]main\.ts$/.test(entryPath) ? "development" : "package";
+}
+function createRuntimeRestartLaunchPlan(options) {
+  const platform2 = options.platform ?? process.platform;
+  const startArgs = formatStartArgs(options.startArgs);
+  const env = compactEnv(options.env);
+  const logPath = pathForPlatform(platform2).join(options.storagePath, "logs", "restart.log");
+  const healthUrl = new URL("/api/system/health", options.localDashboardOrigin).toString();
+  if (options.mode === "development") {
+    const repoRoot2 = resolveDevelopmentRepoRoot(options.cwd, options.env, platform2);
+    const launch2 = createSpawnableCommand(commandName("pnpm", platform2), ["dev:node", "--", ...startArgs], platform2);
+    return {
+      mode: "development",
+      command: launch2.command,
+      args: launch2.args,
+      cwd: repoRoot2,
+      env,
+      displayCommand: launch2.displayCommand,
+      logPath,
+      healthUrl
+    };
+  }
+  const launch = createSpawnableCommand(commandName("npx", platform2), ["-y", "meshy-node@latest", ...startArgs], platform2);
+  return {
+    mode: "package",
+    command: launch.command,
+    args: launch.args,
+    cwd: options.cwd,
+    env,
+    displayCommand: launch.displayCommand,
+    logPath,
+    healthUrl
+  };
+}
+function scheduleRuntimeRestart(plan, options = {}) {
+  fs22.mkdirSync(nodePath2.dirname(plan.logPath), { recursive: true });
+  const logFd = fs22.openSync(plan.logPath, "a");
+  const spawnImpl = options.spawnImpl ?? import_node_child_process14.spawn;
+  const env = {
+    ...process.env,
+    MESHY_RESTART_PARENT_PID: String(options.parentPid ?? process.pid),
+    MESHY_RESTART_PLAN: JSON.stringify(plan)
+  };
+  const child = spawnImpl(process.execPath, ["-e", RESTARTER_SOURCE], {
+    detached: true,
+    env,
+    stdio: ["ignore", logFd, logFd],
+    windowsHide: true
+  });
+  child.unref();
+}
+function createRuntimeUpdateSnapshot(options) {
+  const now = options.now ?? /* @__PURE__ */ new Date();
+  const checkedAt = now.toISOString();
+  const currentVersion = options.runtimeMetadata?.packageVersion ?? null;
+  const packageName = "meshy-node";
+  if (options.mode === "development") {
+    return {
+      packageName,
+      currentVersion,
+      latestVersion: null,
+      updateAvailable: false,
+      checkedAt,
+      restartMode: "development",
+      detail: "Development runtime restarts from the local workspace."
+    };
+  }
+  const cache = options.updateCache ?? runtimeUpdateCache;
+  const checkedOn = formatLocalDate3(now);
+  const cached = cache.get(packageName);
+  let latestVersion = cached?.latestVersion ?? null;
+  let detail = cached?.detail ?? null;
+  let updateCheckedAt = cached?.checkedAt ?? checkedAt;
+  if (cached?.checkedOn !== checkedOn) {
+    const runner = options.commandRunner ?? runRuntimePackageCommand;
+    const result = runner("npm", ["view", `${packageName}@latest`, "version", "--json"]);
+    latestVersion = result.status === 0 ? normalizePackageVersion2(result.stdout) : null;
+    detail = result.status === 0 ? null : normalizeOutput2(result.stderr) ?? result.error ?? "Runtime update check failed";
+    updateCheckedAt = checkedAt;
+    cache.set(packageName, { checkedOn, checkedAt, latestVersion, detail });
+  }
+  return {
+    packageName,
+    currentVersion,
+    latestVersion,
+    updateAvailable: Boolean(currentVersion && latestVersion && compareSemver2(latestVersion, currentVersion) > 0),
+    checkedAt: updateCheckedAt,
+    restartMode: "package",
+    detail
+  };
+}
+
+// src/bootstrap/settings-snapshot.ts
+function createSettingsSnapshotProvider(options) {
+  let cachedSnapshot = null;
+  let cachedSnapshotAt = 0;
+  function buildSnapshot() {
+    cachedSnapshot = buildNodeSettingsSnapshot({
+      auth: options.authMetadata,
+      localDashboardOrigin: options.localDashboardOrigin,
+      runtimeMetadata: options.runtimeMetadata,
+      runtimeUpdate: createRuntimeUpdateSnapshot({
+        mode: options.runtimeRestartMode,
+        runtimeMetadata: options.runtimeMetadata
+      }),
+      storagePath: options.storagePath,
+      workDir: options.workDir
+    });
+    cachedSnapshotAt = Date.now();
+    return structuredClone(cachedSnapshot);
+  }
+  function getSettingsSnapshot() {
+    const now = Date.now();
+    if (cachedSnapshot && now - cachedSnapshotAt < 3e4) {
+      return structuredClone(cachedSnapshot);
+    }
+    return buildSnapshot();
+  }
+  return {
+    getSettingsSnapshot,
+    refreshSettingsSnapshot: () => {
+      cachedSnapshot = null;
+      cachedSnapshotAt = 0;
+      return buildSnapshot();
+    }
+  };
+}
+
 // src/bootstrap/tunnel-health.ts
 var DEFAULT_TUNNEL_REACHABILITY_INTERVAL_MS = 6e4;
 var DEFAULT_TUNNEL_REACHABILITY_TIMEOUT_MS = 5e3;
@@ -50857,36 +51480,6 @@ async function fetchWithTimeout2(fetchImpl, url, timeoutMs) {
 }
 
 // src/bootstrap/start-node.ts
-function createSettingsSnapshotProvider(options) {
-  let cachedSnapshot = null;
-  let cachedSnapshotAt = 0;
-  function buildSnapshot() {
-    cachedSnapshot = buildNodeSettingsSnapshot({
-      auth: options.authMetadata,
-      localDashboardOrigin: options.localDashboardOrigin,
-      runtimeMetadata: options.runtimeMetadata,
-      storagePath: options.storagePath,
-      workDir: options.workDir
-    });
-    cachedSnapshotAt = Date.now();
-    return structuredClone(cachedSnapshot);
-  }
-  function getSettingsSnapshot() {
-    const now = Date.now();
-    if (cachedSnapshot && now - cachedSnapshotAt < 3e4) {
-      return structuredClone(cachedSnapshot);
-    }
-    return buildSnapshot();
-  }
-  return {
-    getSettingsSnapshot,
-    refreshSettingsSnapshot: () => {
-      cachedSnapshot = null;
-      cachedSnapshotAt = 0;
-      return buildSnapshot();
-    }
-  };
-}
 async function resolveStartConfig(args) {
   const configPath = args.config ?? "./config.json";
   const fileConfig = loadConfigFile(configPath);
@@ -50916,7 +51509,7 @@ async function resolveStartConfig(args) {
     ignorePersistedName: args.reset === true
   });
   const config = mergeConfig(defaults, scopedFileConfig, resolvedArgs);
-  setStartupFatalLogPath(nodePath2.join(config.storage.path, "logs", "startup-fatal.log"));
+  setStartupFatalLogPath(nodePath3.join(config.storage.path, "logs", "startup-fatal.log"));
   persistDefaultNodeName(storageRoot, config.node.name);
   persistDefaultNodeName(config.storage.path, config.node.name);
   persistNodeStartupMetadata(config.storage.path, {
@@ -51271,15 +51864,20 @@ function createTunnelManager(options) {
 }
 function registerShutdownHandlers(options) {
   let shuttingDown = false;
-  async function shutdown() {
+  function stopDevelopmentWatchParent(runtimeMode) {
+    if (runtimeMode) terminateRuntimeWatchParent({ mode: runtimeMode, env: process.env });
+  }
+  async function shutdown(reason = "shutdown", runtimeMode) {
     if (shuttingDown) {
       terminalWriter.line("Force exit.");
+      stopDevelopmentWatchParent(runtimeMode);
       process.exit(130);
     }
     shuttingDown = true;
-    terminalWriter.line("\nShutting down...");
+    terminalWriter.line(reason === "restart" ? "\nRestarting..." : "\nShutting down...");
     const forceExitTimer = setTimeout(() => {
       terminalWriter.line("Force exit.");
+      stopDevelopmentWatchParent(runtimeMode);
       process.exit(0);
     }, 1e4);
     forceExitTimer.unref?.();
@@ -51289,15 +51887,21 @@ function registerShutdownHandlers(options) {
       await options.tunnelManager.stop();
       await options.meshyNode.stop();
       clearTimeout(forceExitTimer);
-      terminalWriter.line("Goodbye!");
+      terminalWriter.line(reason === "restart" ? "Restart handoff complete." : "Goodbye!");
+      stopDevelopmentWatchParent(runtimeMode);
       process.exit(0);
     } catch (err) {
       terminalWriter.error("Error during shutdown:", err);
       process.exit(1);
     }
   }
-  process.on("SIGINT", shutdown);
-  process.on("SIGTERM", shutdown);
+  process.on("SIGINT", () => void shutdown("shutdown"));
+  process.on("SIGTERM", () => void shutdown("shutdown"));
+  return {
+    requestShutdown: (reason = "shutdown", runtimeMode) => {
+      void shutdown(reason, runtimeMode);
+    }
+  };
 }
 async function startNode(args) {
   const { authMetadata, config, hydratedArgs, runtimeMetadata, storageRoot } = await resolveStartConfig(args);
@@ -51309,7 +51913,7 @@ async function startNode(args) {
   const localDashboardOrigin = `http://localhost:${config.node.port}`;
   const logger27 = createLogger({
     component: "node",
-    logDir: nodePath2.join(config.storage.path, "logs"),
+    logDir: nodePath3.join(config.storage.path, "logs"),
     console: true
   });
   const nodeAuth = new AzureCliNodeAuth(config.storage.path, {
@@ -51331,8 +51935,9 @@ async function startNode(args) {
     authMetadata,
     localDashboardOrigin,
     runtimeMetadata,
+    runtimeRestartMode: detectRuntimeRestartMode(),
     storagePath: config.storage.path,
-    workDir: nodePath2.resolve(config.node.workDir ?? process.cwd())
+    workDir: nodePath3.resolve(config.node.workDir ?? process.cwd())
   });
   const { getSettingsSnapshot, refreshSettingsSnapshot } = settingsSnapshotProvider;
   const meshyNode = new MeshyNode(config, {
@@ -51348,6 +51953,7 @@ async function startNode(args) {
   const previewSessionManager = new PreviewSessionManager();
   const previewProxyManager = new PreviewProxyManager();
   let deps;
+  let requestShutdownForRestart;
   const tunnelManager = createTunnelManager({
     authMetadata,
     config,
@@ -51424,7 +52030,39 @@ async function startNode(args) {
     isDevTunnelEnabled: () => meshyNode.isDevTunnelEnabled(),
     localDashboardOrigin,
     upgradeRuntimeAgent,
+    restartRuntime: async (request) => {
+      const mode = detectRuntimeRestartMode();
+      const plan = createRuntimeRestartLaunchPlan({
+        mode,
+        cwd: process.cwd(),
+        env: process.env,
+        localDashboardOrigin,
+        startArgs: resolveRuntimeRestartStartArgs(hydratedArgs.args, request.startArgs),
+        storagePath: config.storage.path
+      });
+      scheduleRuntimeRestart(plan, { parentPid: process.pid });
+      const completeShutdown = () => setTimeout(() => requestShutdownForRestart?.("restart", mode), 250).unref?.();
+      if (!request.deferShutdown) completeShutdown();
+      return {
+        ok: true,
+        mode: plan.mode,
+        command: plan.displayCommand,
+        logPath: plan.logPath,
+        pid: process.pid,
+        completeShutdown
+      };
+    },
+    stopRuntime: async () => {
+      const pid = process.pid;
+      const mode = detectRuntimeRestartMode();
+      setTimeout(() => requestShutdownForRestart?.("shutdown", mode), 250).unref?.();
+      return { ok: true, pid };
+    },
     refreshSettingsSnapshot,
+    runtimeUpdate: createRuntimeUpdateSnapshot({
+      mode: detectRuntimeRestartMode(),
+      runtimeMetadata
+    }),
     dashboardOrigin: tunnelManager.getDashboardOrigin(),
     shareOrigin: tunnelManager.getShareOrigin(),
     ensureShareTunnel: () => tunnelManager.ensureShareTunnel(),
@@ -51456,11 +52094,12 @@ async function startNode(args) {
     terminalWriter.line(banner);
     terminalWriter.line("");
   });
-  registerShutdownHandlers({
+  const shutdownHandle = registerShutdownHandlers({
     server,
     meshyNode,
     tunnelManager
   });
+  requestShutdownForRestart = shutdownHandle.requestShutdown;
 }
 
 // src/main.ts